Fold followed hashtags into the Following feed and drop tag tabs

- useFollowingFeed now also queries posts for the user's followed
  hashtag interests (NIP-51 kind 10015 t tags) and merges them into
  the combined Following feed, subject to the same recency floor.
- Drop the per-hashtag and per-geotag tabs from the home feed
  subheader. Legacy 'hashtag:'/'geotag:' session-storage values fall
  back to the Following tab.
- Invalidate the new following-feed query keys when interests change
  so the Following feed refreshes immediately on follow/unfollow.
- Remove the now-dead HashtagFeedContent and GeotagFeedContent
  components and their unused imports.

.agents/skills/capacitor-compat/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: capacitor-compat
+description: Browser-API gotchas inside Capacitor's WKWebView (iOS) and Android WebView — which common web APIs silently fail, the downloadTextFile/openUrl helpers that bridge web and native, platform detection, and the installed Capacitor plugins. Load when writing code that interacts with file downloads, external URLs, or platform-specific behavior.
+---
+
+# Capacitor Compatibility
+
+Ditto runs inside Capacitor's WKWebView on iOS and WebView on Android. Several common web APIs **do not work** in this environment. Always account for native platforms when writing code that interacts with browser-specific features.
+
+## What Doesn't Work in WKWebView (iOS)
+
+- **`<a download>` file downloads** — programmatically creating an anchor with `a.download` and clicking it silently fails. WKWebView ignores the `download` attribute entirely.
+- **`<a target="_blank">` new tabs** — programmatic clicks on anchors with `target="_blank"` are blocked. There are no tabs in a native app.
+- **`window.open()`** — may be blocked or behave unexpectedly without user-gesture context.
+
+For a deeper list of Apple Lockdown Mode restrictions that also affect WKWebView, load the **`lockdown-mode`** skill.
+
+## File Downloads and URL Opening
+
+`src/lib/downloadFile.ts` provides two utilities that handle the web/native split automatically. **Always use these** instead of manually constructing anchors.
+
+### `downloadTextFile(filename, content)`
+
+Saves a text file to the user's device. On web it uses the `<a download>` pattern. On native it writes to the Capacitor cache directory via `@capacitor/filesystem` and presents the native share sheet via `@capacitor/share`.
+
+```typescript
+import { downloadTextFile } from '@/lib/downloadFile';
+
+await downloadTextFile('backup.txt', fileContents);
+```
+
+### `openUrl(url)`
+
+Opens a URL in a new browser tab on web, or presents the native share sheet on Capacitor.
+
+```typescript
+import { openUrl } from '@/lib/downloadFile';
+
+await openUrl('https://example.com/image.jpg');
+```
+
+**CRITICAL**: Never use `document.createElement('a')` with `.click()` for downloads or opening URLs. The utilities above work correctly on all platforms; manual anchors silently fail on iOS.
+
+## Detecting Native Platforms
+
+Use `Capacitor.isNativePlatform()` from `@capacitor/core` when you need platform-specific behavior:
+
+```typescript
+import { Capacitor } from '@capacitor/core';
+
+if (Capacitor.isNativePlatform()) {
+  // iOS or Android
+} else {
+  // Web browser
+}
+```
+
+Reserve platform forks for cases where behavior genuinely differs (share sheets, secure storage, haptics). Most UI code should stay platform-agnostic.
+
+## Installed Capacitor Plugins
+
+- `@capacitor/app` — app lifecycle events (deep links, back button)
+- `@capacitor/core` — core runtime and platform detection
+- `@capacitor/filesystem` — read/write files on the native filesystem
+- `@capacitor/haptics` — native haptics
+- `@capacitor/keyboard` — keyboard control (hide accessory bar, etc.)
+- `@capacitor/local-notifications` — schedule local push notifications
+- `@capacitor/share` — native share sheet
+- `@capacitor/status-bar` — control the native status-bar style
+- `@capgo/capacitor-autofill-save-password` — iOS keychain autofill for nsec
+- `capacitor-secure-storage-plugin` — OS-level secure storage (iOS Keychain / Android KeyStore)
+
+After adding or removing plugins, run `npm run cap:sync` to update the native projects.

.agents/skills/ci-cd-publishing/SKILL.md

@@ -0,0 +1,350 @@
+---
+name: ci-cd-publishing
+description: Ditto's release and publishing pipeline — cutting a version tag, Zapstore APK publishing with NIP-46 bunker auth, nsite web deploys via nsyte, and Google Play AAB uploads via fastlane supply. Includes GitLab CI variable setup and credential rotation.
+---
+
+# CI/CD Pipeline and Publishing
+
+Ditto uses GitLab CI (`.gitlab-ci.yml`) to run tests on every commit, deploy the web app to nsite on every default-branch push, and build + publish Android binaries to Zapstore and Google Play on every tag. Load this skill when setting up CI credentials, rotating a signing key, diagnosing a failed publish, or adding a new publishing target.
+
+## Pipeline Overview
+
+| Stage     | Runs on                   | Job                                     |
+|-----------|---------------------------|-----------------------------------------|
+| `test`    | every commit (not tags)   | `npm run test`                          |
+| `deploy`  | default branch only       | `deploy-nsite` (Vite build → nsyte)     |
+| `build`   | tags only                 | `build-apk` (signed APK + AAB) + `build-ipa` (signed IPA on the Mac runner) |
+| `release` | tags only                 | GitLab Release with APK / AAB / IPA links |
+| `publish` | tags only                 | `publish-zapstore` + `publish-google-play` + `publish-app-store` |
+
+## Creating a Release
+
+Releases are triggered by pushing a version tag:
+
+```bash
+npm run release
+```
+
+This creates a tag in the format `v2026.03.14+abc1234` (date + short commit hash) and pushes it to GitLab, which triggers the `build-apk`, `release`, `publish-zapstore`, and `publish-google-play` jobs.
+
+For the full versioning / changelog / native-build workflow, load the **`release`** skill.
+
+## Zapstore Publishing
+
+The `publish-zapstore` CI job uploads signed APKs to [Zapstore](https://zapstore.dev/) using the [`zsp`](https://github.com/zapstore/zsp) CLI and NIP-46 bunker signing via Amber.
+
+**Configuration files:**
+
+- `zapstore.yaml` — app metadata for Zapstore (name, tags, icon, supported NIPs)
+- `.gitlab-ci.yml` — the `publish-zapstore` job definition
+
+**GitLab CI/CD variables** (Settings → CI/CD → Variables):
+
+| Variable | Description | Protected | Masked | Raw |
+|---|---|---|---|---|
+| `ZAPSTORE_BUNKER_URL` | NIP-46 bunker URL (`bunker://<pubkey>?relay=...`). No `secret` param needed after initial auth. | Yes | No | Yes |
+| `ZAPSTORE_CLIENT_KEY` | Hex private key used as the NIP-46 client identity for bunker communication | Yes | Yes | Yes |
+| `ANDROID_KEYSTORE_BASE64` | Base64-encoded Android signing keystore | Yes | Yes | Yes |
+| `KEYSTORE_PASSWORD` | Android keystore password | Yes | Yes | Yes |
+| `KEY_PASSWORD` | Android key password | Yes | Yes | Yes |
+
+### How NIP-46 bunker auth works in CI
+
+NIP-46 bunker signing requires two keys: the **user's key** (held by Amber) and a **client key** (the CI runner's identity). The bunker authorizes specific client pubkeys — once authorized, the client can request signatures without re-approval.
+
+The `publish-zapstore` job restores the client key from `ZAPSTORE_CLIENT_KEY` into `~/.config/zsp/bunker-keys/<bunker-pubkey>.key` before running `zsp`, so the bunker recognizes the CI runner as an already-authorized client.
+
+### Initial setup (one-time)
+
+Run the NIP-46 client-initiated auth script:
+
+```bash
+node scripts/nip46-auth.mjs
+```
+
+This generates a `nostrconnect://` URI. Import/paste it into Amber and approve the connection. The script outputs the `bunker://` URI and client key hex, and writes the client key to `~/.config/zsp/bunker-keys/`. Update the GitLab CI/CD variables with the printed values.
+
+Options:
+- `--relay <url>` — relay for NIP-46 communication (default: `wss://relay.ditto.pub`)
+- `--name <name>` — app name shown to the signer (default: `Ditto`)
+- `--timeout <sec>` — how long to wait for approval (default: 300)
+
+After authorization, the bunker recognizes the client key and no secret or manual approval is needed for CI runs. If the client key is rotated, run the script again and update the GitLab variables.
+
+## nsite Publishing
+
+The `deploy-nsite` CI job deploys the Vite build to [nsite](https://nsite.run) on every push to the default branch using [nsyte](https://github.com/sandwichfarm/nsyte). The job uploads `dist/` to Blossom servers and publishes site manifest events to Nostr relays.
+
+nsyte uses a NIP-46 bunker credential called **nbunksec** — a bech32-encoded string bundling the bunker pubkey, client secret key, and relay info into a single self-contained token. It's passed to nsyte via `--sec`.
+
+**GitLab CI/CD variables:**
+
+| Variable | Description | Protected | Masked | Raw |
+|---|---|---|---|---|
+| `NSITE_NBUNKSEC` | nbunksec credential from `nsyte ci`. Must start with `nbunksec1`. | Yes | Yes | Yes |
+
+### Initial setup (one-time)
+
+1. Install nsyte locally:
+   ```bash
+   curl -fsSL https://nsyte.run/get/install.sh | bash
+   ```
+2. Generate the CI credential:
+   ```bash
+   nsyte ci
+   ```
+   This guides you through connecting a NIP-46 bunker (e.g. Amber) and outputs an `nbunksec1...` string. The credential is shown only once.
+3. Add the `nbunksec1...` value as `NSITE_NBUNKSEC` in GitLab CI/CD settings. Mark it as **Protected** and **Masked**.
+
+### Configured relays and servers
+
+Relays the deploy job publishes to:
+
+- `wss://relay.ditto.pub`
+- `wss://relay.nsite.lol`
+- `wss://relay.dreamith.to`
+- `wss://relay.primal.net`
+
+Blossom servers:
+
+- `https://blossom.primal.net`
+- `https://blossom.ditto.pub`
+- `https://blossom.dreamith.to`
+
+The `--use-fallback-relays` and `--use-fallback-servers` flags include nsyte's built-in defaults for broader coverage. The `--fallback "/index.html"` flag enables SPA client-side routing.
+
+### Credential rotation
+
+To rotate the nsite credential:
+
+1. Revoke the old bunker connection in your signer app.
+2. Run `nsyte ci` again to generate a new `nbunksec1...` string.
+3. Update the `NSITE_NBUNKSEC` variable in GitLab CI/CD settings.
+
+## Google Play Publishing
+
+The `publish-google-play` CI job uploads Android AABs to [Google Play](https://play.google.com/store/apps/details?id=pub.ditto.app) using [fastlane supply](https://docs.fastlane.tools/actions/supply/). It runs after a successful AAB build and uploads directly to the production track.
+
+**GitLab CI/CD variables:**
+
+| Variable | Description | Protected | Masked | Raw |
+|---|---|---|---|---|
+| `GOOGLE_PLAY_SERVICE_ACCOUNT_JSON` | **Base64-encoded** contents of the Google Play API service account key JSON. The CI job decodes with `base64 -d` before passing to `fastlane supply`. | Yes | Yes | No |
+
+### Initial setup (one-time)
+
+1. Create or reuse a project in [Google Cloud Console](https://console.cloud.google.com/projectcreate).
+2. Enable the [Google Play Developer API](https://console.developers.google.com/apis/api/androidpublisher.googleapis.com/) for that project.
+3. In Google Cloud Console, go to [Service Accounts](https://console.cloud.google.com/iam-admin/serviceaccounts), create a service account, and download a JSON key file for it.
+4. In Google Play Console, go to [Users & Permissions](https://play.google.com/console/users-and-permissions), click **Invite new users**, enter the service account email, and grant it permission to manage releases for `pub.ditto.app`.
+5. **Base64-encode** the key file:
+
+   ```bash
+   # Linux
+   base64 -w0 service-account.json
+
+   # macOS
+   base64 -i service-account.json | tr -d '\n'
+   ```
+
+6. Add the base64-encoded value as `GOOGLE_PLAY_SERVICE_ACCOUNT_JSON` in GitLab CI/CD settings. Mark it as **Protected** and **Masked**. **Do not paste the raw JSON** — the CI script expects base64 and will fail to decode a raw value.
+
+### Key points
+
+- The job uploads the signed **AAB** (not APK) — Google Play requires App Bundles.
+- Uploads go directly to the **production** track. Google's review process still applies before the update reaches users.
+- Metadata, screenshots, and store-listing description are managed in the Play Console (the job uses `--skip_upload_metadata`, `--skip_upload_images`, `--skip_upload_screenshots`).
+- **Changelogs ("What's new in this version")** are uploaded from `android/fastlane/metadata/android/en-US/changelogs/<versionCode>.txt`, generated at CI time from the release summary paragraph in `CHANGELOG.md`. See "Release notes pipeline" below.
+- The same signing keystore used for Zapstore is reused here (`ANDROID_KEYSTORE_BASE64`, `KEYSTORE_PASSWORD`, `KEY_PASSWORD`).
+
+## App Store Publishing
+
+Ditto's iOS pipeline is split across two jobs:
+
+- **`build-ipa`** (stage `build`, `tags: [macos]`) runs on the self-hosted Mac runner. Decodes the App Store Connect API key, fetches the encrypted distribution cert + provisioning profile via fastlane match, builds the web assets, runs `cap sync ios`, stamps the marketing version into `project.pbxproj`, then `fastlane build_ipa` produces a signed App Store IPA at `artifacts/Ditto.ipa`. The IPA is uploaded to the GitLab Generic Packages registry as `Ditto-${CI_COMMIT_TAG}.ipa` (mirrors how `build-apk` publishes the APK and AAB) and exposed as a CI artifact for downstream jobs.
+- **`publish-app-store`** (stage `publish`, `tags: [macos]`) also runs on the self-hosted Mac runner. Consumes the IPA artifact via `needs: [build-ipa]` and the release-notes artifact via `needs: [release-notes]`. Decodes the API key, copies the release-notes summary into `ios/fastlane/metadata/en-US/release_notes.txt`, and runs `fastlane submit_release` which calls `deliver` to upload metadata + push the prebuilt IPA + auto-submit for App Store review. **macOS is required** even though the IPA is already signed: `fastlane deliver` shells out to Apple's iTMSTransporter / altool to upload the binary, and those tools only ship inside Xcode. A Linux container ran into `No such file or directory @ dir_chdir0` from `JavaTransporterExecutor#execute` because `Helper.itms_path` resolved to a missing Xcode path.
+
+The Mac runner is therefore used for both iOS jobs. For runner administration (operating the Mac, restarting the agent, viewing logs, rotating signing certs), load the **`mac-runner`** skill.
+
+**Configuration files:**
+
+- `ios/fastlane/Fastfile` — exposes four lanes:
+  - `build_ipa` — setup_ci → match (readonly, with API key) → increment_build_number → build_app. Used by CI's `build-ipa`.
+  - `submit_release` — reads `IPA_PATH` env var, calls deliver against the prebuilt IPA. Used by CI's `publish-app-store`.
+  - `release` — combines build_ipa + submit_release; convenience for local one-shot runs.
+  - `submit_only` — debug lane that skips build/upload and only runs deliver against an already-uploaded build (set `BUILD_NUMBER` + `VERSION` env vars). See the `mac-runner` skill.
+- `ios/fastlane/Appfile` — bundle identifier and team ID
+- `ios/fastlane/Matchfile` — points at the shared `soapbox-pub/certificates` repo
+- `ios/fastlane/metadata/en-US/release_notes.txt` — placeholder; CI overwrites it with the release summary paragraph from `CHANGELOG.md` per release
+- `.gitlab-ci.yml` — `build-ipa` and `publish-app-store` both run on the Mac runner (`tags: [macos]`)
+
+**Code signing storage**: a private GitLab repo `soapbox-pub/certificates` holds encrypted distribution certs and provisioning profiles, managed by [fastlane match](https://docs.fastlane.tools/actions/match/). Match handles cert/profile lifecycle: one passphrase decrypts everything; the same repo can hold signing material for multiple Soapbox iOS apps under team `GZLTTH5DLM`.
+
+**App Store Connect auth**: a long-lived [App Store Connect API key](https://developer.apple.com/documentation/appstoreconnectapi/creating-api-keys-for-app-store-connect-api) (`.p8` file + key ID + issuer ID) authenticates `match`, `deliver`, and `pilot`. Avoids 2FA prompts that would interrupt CI.
+
+**Distribution**: `submit_for_review: true` automatically pushes the build into Apple's review queue once uploaded. `automatic_release: false` keeps a human-controlled final gate — once Apple approves, you click "Release" in the App Store Connect web UI to publish to users. To remove the manual gate, flip `automatic_release` to `true` in `ios/fastlane/Fastfile`.
+
+**Release notes**: copied from the `release-notes` job's artifact `artifacts/release-notes-summary.txt` (the leading plaintext paragraph of the version's `CHANGELOG.md` section) into `ios/fastlane/metadata/en-US/release_notes.txt`, uploaded by `deliver` as the App Store "What's New in This Version" text. See "Release notes pipeline" below.
+
+**IPA distribution beyond the App Store**: `build-ipa` uploads the signed IPA to the GitLab Generic Packages registry, and the `release` job links it from the GitLab Release page. The IPA is signed with the App Store distribution profile, so it isn't directly sideloadable — installation goes through Apple's review process — but having it as a stable artifact lays the groundwork for AltStore or ad-hoc distribution later (which would require a separate provisioning profile).
+
+**GitLab CI/CD variables:**
+
+| Variable | Description | Protected | Masked | Raw |
+|---|---|---|---|---|
+| `MATCH_PASSWORD` | Symmetric passphrase used by match to encrypt/decrypt certs and profiles. The single most important secret — losing it makes the cert repo unreadable. | Yes | Yes | Yes |
+| `MATCH_GIT_BASIC_AUTHORIZATION` | Base64 of `username:deploy-token` for HTTPS clone of the certificates repo. Generated from a `read_repository`-scoped deploy token on `soapbox-pub/certificates`. | Yes | Yes | Yes |
+| `APP_STORE_CONNECT_API_KEY_ID` | App Store Connect API key ID (10 chars). | Yes | No | Yes |
+| `APP_STORE_CONNECT_API_KEY_ISSUER_ID` | App Store Connect issuer ID (UUID). | Yes | No | Yes |
+| `APP_STORE_CONNECT_API_KEY_P8_BASE64` | Base64-encoded contents of the `.p8` private key file. CI decodes with `base64 -d` into `~/.private_keys/AuthKey_<KEY_ID>.p8` and removes it in `after_script`. | Yes | Yes | Yes |
+| `FASTLANE_KEYCHAIN_PASSWORD` | Password for the ephemeral keychain `setup_ci` creates per build. Random per setup; keep stable across runs. | Yes | Yes | Yes |
+
+### Initial setup (one-time)
+
+1. **Provision the Mac runner.** See the **`mac-runner`** skill for hardware/launchd setup, Xcode, Homebrew, fastlane, and `gitlab-runner` registration.
+
+2. **Create the App Store Connect API key.** Log in to [App Store Connect](https://appstoreconnect.apple.com) → Users and Access → Integrations → App Store Connect API → Generate. Use the **App Manager** role (sufficient for `deliver`'s upload + submit-for-review). Download the `.p8` file (one-time download — Apple won't show it again). Note the **Key ID** (10-char string next to the key) and the **Issuer ID** (UUID at the top of the API page).
+
+   Set the three GitLab CI variables:
+   ```bash
+   # Replace <ISSUER_ID>, <KEY_ID>, and the path to your .p8
+   curl -X POST -H "PRIVATE-TOKEN: $GITLAB_TOKEN" \
+     "https://gitlab.com/api/v4/projects/$PROJECT_ID/variables" \
+     --data-urlencode "key=APP_STORE_CONNECT_API_KEY_ISSUER_ID" \
+     --data-urlencode "value=<ISSUER_ID>" \
+     --data-urlencode "protected=true" --data-urlencode "raw=true"
+   # repeat for APP_STORE_CONNECT_API_KEY_ID
+   # for the .p8, base64 first:
+   base64 -i AuthKey_<KEY_ID>.p8 | tr -d '\n'  # paste this as APP_STORE_CONNECT_API_KEY_P8_BASE64 (masked)
+   ```
+
+3. **Create the certificates repo.** A private GitLab repo at `soapbox-pub/certificates` holds match-encrypted certs/profiles. Create a project deploy token on it (Settings → Repository → Deploy tokens) with `read_repository` scope. Encode `username:token` as base64 → set as `MATCH_GIT_BASIC_AUTHORIZATION` (protected, masked, raw).
+
+4. **Generate `MATCH_PASSWORD` and `FASTLANE_KEYCHAIN_PASSWORD`.** Both are arbitrary strong random strings — `openssl rand -base64 32 | tr -d '=+/' | head -c 32` works. Store them as protected, masked GitLab variables.
+
+5. **Bootstrap match certs via a one-shot CI job** (preferred over running match locally — avoids the macOS keychain UI permission dialogs that fastlane bug [#15185](https://github.com/fastlane/fastlane/issues/15185) trips on newer macOS):
+
+   a. Create a temporary write-scoped GitLab variable. The deploy token is `read_repository`; for the initial cert creation match needs to push. Encode `username:write-pat` as base64 and set it as `MATCH_GIT_BASIC_AUTHORIZATION_WRITE` (Protected, Masked, Raw).
+
+   b. Add a temporary `setup-match` job to `.gitlab-ci.yml` that runs on the macos runner with `setup_ci` (which creates an ephemeral keychain — bypasses the GUI permission issue):
+
+      ```yaml
+      setup-match:
+        stage: publish
+        tags: [macos]
+        rules:
+          - if: $SETUP_MATCH == "1"
+            when: manual
+        script:
+          - export ASC_KEY_PATH="$HOME/.private_keys/AuthKey_${APP_STORE_CONNECT_API_KEY_ID}.p8"
+          - mkdir -p "$HOME/.private_keys" && chmod 700 "$HOME/.private_keys"
+          - echo "$APP_STORE_CONNECT_API_KEY_P8_BASE64" | base64 -d > "$ASC_KEY_PATH"
+          - chmod 600 "$ASC_KEY_PATH"
+          - cd ios
+          - export MATCH_GIT_BASIC_AUTHORIZATION="$MATCH_GIT_BASIC_AUTHORIZATION_WRITE"
+          - unset APP_STORE_CONNECT_API_KEY_PATH || true
+          - |
+            cat > Fastfile.setup <<'RUBY'
+            default_platform(:ios)
+            platform :ios do
+              lane :setup do
+                setup_ci
+                api_key = {
+                  key_id: ENV.fetch("APP_STORE_CONNECT_API_KEY_ID"),
+                  issuer_id: ENV.fetch("APP_STORE_CONNECT_API_KEY_ISSUER_ID"),
+                  key: File.binread(ENV.fetch("ASC_KEY_PATH")),
+                  duration: 1200,
+                  in_house: false,
+                }
+                match(type: "appstore", readonly: false, api_key: api_key, force_for_new_devices: true)
+              end
+            end
+            RUBY
+          - mv fastlane/Fastfile fastlane/Fastfile.bak
+          - mv Fastfile.setup fastlane/Fastfile
+          - fastlane setup
+          - mv fastlane/Fastfile.bak fastlane/Fastfile
+        after_script:
+          - rm -f "$HOME/.private_keys"/AuthKey_*.p8 || true
+      ```
+
+   c. Trigger the pipeline manually with `SETUP_MATCH=1`:
+
+      ```bash
+      curl -X POST -H "PRIVATE-TOKEN: $GITLAB_TOKEN" \
+        "https://gitlab.com/api/v4/projects/$PROJECT_ID/pipeline" \
+        --data-urlencode "ref=main" \
+        --data-urlencode "variables[][key]=SETUP_MATCH" \
+        --data-urlencode "variables[][value]=1"
+      # Then play the manual setup-match job
+      ```
+
+   d. Once the job succeeds (cert + profile pushed to the certificates repo), **delete the `setup-match` job from `.gitlab-ci.yml` and the `MATCH_GIT_BASIC_AUTHORIZATION_WRITE` variable**. They're only needed for bootstrap.
+
+### Yearly cert renewal
+
+Apple distribution certs expire annually. Renewal is one command per year, run on any Mac:
+
+```bash
+cd ~/Projects/ditto/ios
+fastlane match nuke distribution      # revokes old cert in Apple's portal, removes from match repo
+fastlane match appstore               # creates new cert + profile, encrypts, commits, pushes
+```
+
+CI's next tag run picks up the new files automatically (`match(... readonly: true)`).
+
+### Disaster recovery (Mac dies / new developer joins)
+
+```bash
+git clone https://gitlab.com/soapbox-pub/ditto.git
+cd ditto/ios
+fastlane match appstore --readonly    # decrypts existing certs/profiles using MATCH_PASSWORD
+```
+
+No re-issuance of certs needed — the cert repo is the source of truth.
+
+### App Store Connect API key rotation
+
+App Store Connect API keys can be revoked anytime. To rotate:
+
+1. App Store Connect → Users and Access → Integrations → App Store Connect API → Generate new key
+2. Download the new `.p8`, note the new key ID
+3. Update `APP_STORE_CONNECT_API_KEY_ID` and `APP_STORE_CONNECT_API_KEY_P8_BASE64` in GitLab variables
+4. (Issuer ID stays the same — it's per-team, not per-key)
+5. Revoke the old key in App Store Connect
+
+### Key points
+
+- `build-ipa` (Mac) produces a signed **IPA** (App Store distribution format) and uploads it to GitLab's Generic Packages registry. `publish-app-store` (also Mac) submits it to Apple via `deliver`.
+- Builds go to **App Store Connect**, automatically submit for review, but do **not** auto-release after approval. The final "Release" click is manual in the web UI.
+- Marketing version comes from the git tag (`v2.1.0` → `MARKETING_VERSION = 2.1.0`); build number comes from `CI_PIPELINE_IID`.
+- Release notes ("What's New in This Version") come from the release-notes summary paragraph (see "Release notes pipeline" below).
+- `setup_ci` (in `build-ipa`) creates an ephemeral keychain per build, so the runner never touches the login keychain — works whether or not a GUI session is logged in.
+- `publish-app-store` does no code signing, but it still needs macOS: `fastlane deliver` shells out to Apple's iTMSTransporter / altool to upload the binary, and those tools only ship inside Xcode.
+
+## Release notes pipeline
+
+Release notes for all three storefronts (App Store, Google Play, GitLab Release page) and the in-app version-update toast are derived from a single source: `CHANGELOG.md`.
+
+**The `release-notes` job** (stage `build`, default `node:22` image, runs only on `v*` tags) calls `scripts/extract-release-notes.mjs` twice and publishes two artifacts:
+
+- `artifacts/release-notes.md` — the full section for this version (summary paragraph + `### Added` / `### Changed` / etc. lists). Used as the GitLab Release description.
+- `artifacts/release-notes-summary.txt` — only the leading plaintext paragraph (max 500 chars by convention). Used as the App Store / Play Store "What's new" text. Falls back to `Ditto vX.Y.Z` if the section has no summary paragraph.
+
+**Downstream consumers** all pull from the `release-notes` job via `needs:`:
+
+| Consumer | Job | Artifact used |
+|---|---|---|
+| GitLab Release description | `release` | `release-notes.md` |
+| App Store "What's New" | `publish-app-store` | `release-notes-summary.txt` → copied to `ios/fastlane/metadata/en-US/release_notes.txt` → uploaded by `deliver` |
+| Play Store "What's new" | `publish-google-play` | `release-notes-summary.txt` → copied to `android/fastlane/metadata/android/en-US/changelogs/<versionCode>.txt` → uploaded by `supply` |
+| In-app toast | `src/components/VersionCheck.tsx` (runtime) | Re-parses `public/CHANGELOG.md` via `parseChangelog()` and reads `entry.summary` (with a fallback to the legacy first-bullet behavior) |
+
+**The summary format** is documented in the `release` skill — a single plaintext paragraph immediately under the `## [X.Y.Z] - YYYY-MM-DD` heading, before any `### Category`. The script enforces nothing on the parser side; CI emits a warning when the summary exceeds 500 chars but does not fail the build.
+
+**To preview locally** what each storefront will receive:
+
+```bash
+node scripts/extract-release-notes.mjs vX.Y.Z              # full GitLab Release body
+node scripts/extract-release-notes.mjs vX.Y.Z --summary    # storefront blurb
+```

.agents/skills/file-uploads/SKILL.md

@@ -0,0 +1,83 @@
+---
+name: file-uploads
+description: Upload files (images, media, attachments) from the browser to a Blossom server via the useUploadFile hook, and attach them to Nostr events with NIP-94 imeta tags.
+---
+
+# File Uploads on Nostr
+
+This project includes a `useUploadFile` hook that uploads files to Blossom servers and returns NIP-94-compatible tags. Use it whenever a feature needs to accept a user-provided file (avatars, banners, post attachments, etc.).
+
+## The `useUploadFile` Hook
+
+```tsx
+import { useUploadFile } from "@/hooks/useUploadFile";
+
+function MyComponent() {
+  const { mutateAsync: uploadFile, isPending: isUploading } = useUploadFile();
+
+  const handleUpload = async (file: File) => {
+    try {
+      // Returns an array of NIP-94-compatible tags.
+      // The first tag is the `url` tag; its second element is the file URL.
+      const tags = await uploadFile(file);
+      const url = tags[0][1];
+      // ...use the url
+    } catch (error) {
+      // ...handle errors (show a toast, etc.)
+    }
+  };
+
+  // ...rest of component
+}
+```
+
+The hook is a TanStack Query mutation, so `isPending` can drive loading UI and `mutateAsync` integrates cleanly with `async`/`await` flows.
+
+## Attaching Files to Events
+
+### Kind 0 (profile metadata)
+
+Use the plain URL in the relevant JSON field:
+
+```ts
+const tags = await uploadFile(file);
+const url = tags[0][1];
+
+createEvent({
+  kind: 0,
+  content: JSON.stringify({ ...existingMetadata, picture: url }),
+});
+```
+
+### Kind 1 (text notes) and other content events
+
+Append the URL to `content`, and add one `imeta` tag per file. `imeta` carries the NIP-94 metadata (mime type, dimensions, blurhash, etc.) that the uploader returned:
+
+```ts
+const tags = await uploadFile(file); // e.g. [["url", "https://..."], ["m", "image/png"], ["dim", "1024x768"], ...]
+const url = tags[0][1];
+
+// Flatten the NIP-94 tags into a single imeta tag value.
+const imeta = tags.map(([name, value]) => `${name} ${value}`);
+
+createEvent({
+  kind: 1,
+  content: `Check this out ${url}`,
+  tags: [["imeta", ...imeta]],
+});
+```
+
+Repeat the pattern (one `imeta` tag per file) for multiple attachments.
+
+## Common Patterns
+
+- **Avatar / banner pickers:** wrap an `<input type="file" accept="image/*">` and call `uploadFile` on change; on success, update the relevant profile field and publish a kind 0 event.
+- **Post composers:** call `uploadFile` for each selected file before publishing the note, then build `imeta` tags alongside `content`.
+- **Progress UI:** use `isPending` from the mutation to disable the submit button and show a spinner or skeleton.
+- **Error handling:** wrap `uploadFile` in `try/catch` and surface failures via `useToast` — network and Blossom-server errors are common and should never break the UI.
+
+## Constraints
+
+- The hook requires a logged-in user (Blossom auth is signed by the user's signer). Guard uploads behind `useCurrentUser`.
+- Don't store or display raw `File` objects after upload — always use the returned URL.
+- Large files may take time; prefer `mutateAsync` over `mutate` so the caller can `await` completion before publishing an event that references the URL.

.agents/skills/git-workflow/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: git-workflow
+description: Ditto's git conventions — validating changes before committing, writing commit messages that match project style, and attributing regressions with a Regression-of trailer so the release changelog skill can filter them from the "Fixed" section.
+---
+
+# Git Workflow
+
+Ditto expects every completed task to end with a git commit. This skill covers the pre-commit validation loop, commit-message conventions, and the `Regression-of:` trailer used by the release skill to filter intra-release regressions from the changelog.
+
+## Pre-commit Validation
+
+**Your task is not finished until the code type-checks and builds without errors.** In priority order:
+
+1. **Type Checking** (required) — `tsc --noEmit`
+2. **Building/Compilation** (required) — `vite build`
+3. **Linting** (recommended; fix anything critical) — `eslint`
+4. **Tests** (if available) — `vitest run`
+5. **Git commit** (required)
+
+The full `npm run test` script runs all of these in sequence; running it is equivalent to steps 1–4.
+
+## Using Git
+
+Use `git status` and `git diff` to review changes, and `git log` to learn the project's commit-message conventions before writing a new one. If you make a mistake, `git checkout` restores files.
+
+When your changes are complete and validated, create a commit with a message that focuses on **why** the change was made (not just **what**). Summaries should fit on one line; a body is warranted for non-trivial changes.
+
+**Always commit when you are finished making changes. Non-negotiable — every completed task ends with a commit. Don't leave uncommitted changes.**
+
+## Contributing Guide
+
+When preparing changes for a merge request, also follow the guidelines in `CONTRIBUTING.md`. It includes a self-review checklist (step 8) that should be run against your diff before committing.
+
+## Attributing Regressions
+
+When a commit fixes a bug that was introduced by an identifiable prior commit, add a `Regression-of:` trailer at the bottom of the commit message body referencing the offending commit's short SHA:
+
+```
+Fix missing background on expanded emoji picker in feeds
+
+The compose box overhaul accidentally dropped the bg-background class
+when refactoring the picker out of QuickReactMenu.
+
+Regression-of: 3aa08ba9
+```
+
+This is a standard Git trailer (compatible with `git interpret-trailers`) that records the cause-and-effect link directly in history. It is consumed by the `release` skill to detect intra-release regressions and exclude them from the changelog's "Fixed" section, and it makes future debugging and post-mortems substantially faster.
+
+### When to add it
+
+- The commit fixes a bug (not a new feature, refactor, or doc change).
+- The introducing commit is identifiable with reasonable effort.
+
+### When to skip it
+
+- The bug is pre-existing with no clear single origin.
+- The behavior was always wrong (no regression).
+- The introducing commit cannot be determined after a brief search.
+
+### Finding the introducing commit
+
+- `git log -S '<removed-or-changed-string>'` — find commits that touched a specific string.
+- `git log --oneline -- path/to/file` — list all commits touching a file.
+- `git blame -L <start>,<end> -- path/to/file` — find who last changed specific lines.
+
+This convention is **strongly recommended but not required.** When the origin is non-obvious, prioritize shipping the fix over hunting indefinitely.

.agents/skills/mac-runner/SKILL.md

@@ -0,0 +1,249 @@
+---
+name: mac-runner
+description: Operate the self-hosted GitLab Runner on the Mac that builds Ditto's iOS IPA. Covers SSH access, restarting the runner, viewing logs, updating Xcode, debugging fastlane locally, and rotating match certificates.
+---
+
+# Mac Runner Operations
+
+Ditto's iOS pipeline runs two CI jobs on a self-hosted GitLab Runner on a MacBook in the rack: `build-ipa` (signs and builds the IPA via Xcode + fastlane match) and `publish-app-store` (uploads the IPA via `fastlane deliver`, which shells out to Apple's iTMSTransporter — that tool only ships inside Xcode, so this job can't run on Linux). This skill covers operating the Mac.
+
+This skill covers operating the runner: SSH access, restarting after crashes or Xcode updates, watching logs, debugging fastlane locally, and rotating the match certificates. For initial provisioning, App Store Connect API key creation, and GitLab CI variable setup, load the **`ci-cd-publishing`** skill.
+
+## Quick reference
+
+| Need | Command |
+|---|---|
+| SSH in | `ssh alex@alexs-air.lan` |
+| Runner status | `gitlab-runner status` |
+| Restart runner | `gitlab-runner restart` (after `eval "$(/opt/homebrew/bin/brew shellenv)"`) |
+| Stdout log | `tail -f ~/gitlab-runner.out.log` |
+| Stderr log | `tail -f ~/gitlab-runner.err.log` |
+| Runner config | `~/.gitlab-runner/config.toml` |
+| LaunchAgent plist | `~/Library/LaunchAgents/gitlab-runner.plist` |
+
+## Architecture
+
+- **Host**: `alexs-air.lan` (Apple Silicon MacBook, macOS 26+, Xcode 26+)
+- **User**: `alex` (the runner runs in user-mode so it can access keychain and Xcode UI tooling)
+- **Tooling**: Homebrew (`/opt/homebrew`), `gitlab-runner`, `node@22`, `ruby@3.3`, fastlane installed as a user gem under `~/.gem/ruby/3.3.0/`
+- **Service**: launchd LaunchAgent at `~/Library/LaunchAgents/gitlab-runner.plist`. `KeepAlive=true` (auto-restart on crash) and `RunAtLoad=true` (starts on login). The agent loads when `alex` logs in via auto-login at boot.
+- **Tags**: `macos`, `ios`, `xcode` — both `build-ipa` and `publish-app-store` in `.gitlab-ci.yml` target this runner. `publish-app-store` doesn't sign anything, but it still needs Xcode's bundled iTMSTransporter to push the IPA to App Store Connect.
+- **Shell setup**: `~/.bash_profile` sources brew shellenv and prepends `~/.gem/ruby/3.3.0/bin` and `/opt/homebrew/opt/ruby@3.3/bin` to `PATH` so `bash --login` (the runner's executor) finds fastlane + ruby 3.3.
+
+### Why Ruby 3.3, not the brewed 4.0
+
+Brewed `fastlane` (current version) ships running on Ruby 4.0 from `brew install ruby`. Ruby 4.0's OpenSSL bindings hit fastlane bug [#20553](https://github.com/fastlane/fastlane/issues/20553) — `OpenSSL::PKey::EC.new(pem)` raises "invalid curve name" for `prime256v1` keys, which breaks every App Store Connect API key signing operation. Ruby 3.3.x doesn't have this bug. So we install fastlane via `gem install fastlane --user-install` on `ruby@3.3` instead of `brew install fastlane`.
+
+### Why IPv6 is disabled on Wi-Fi
+
+`networksetup -setv6off Wi-Fi` is set because Ruby's net/http on this machine attempted IPv6 to `rubygems.org` first and timed out (~30 s per request). Disabling IPv6 on the Wi-Fi interface forces IPv4 immediately. To re-enable: `sudo networksetup -setv6automatic Wi-Fi`.
+
+## Verifying the runner is healthy
+
+From any machine:
+
+```bash
+curl -s -H "PRIVATE-TOKEN: $GITLAB_TOKEN" \
+  "https://gitlab.com/api/v4/runners/53111580" \
+  | python3 -c "import json,sys;d=json.load(sys.stdin);print(d['status'], d['online'])"
+```
+
+Expected: `online True`. If `offline` or `not_connected`, SSH in and check:
+
+```bash
+ssh alex@alexs-air.lan
+gitlab-runner status
+ps aux | grep gitlab-runner
+tail -50 ~/gitlab-runner.err.log
+```
+
+## Restarting the runner
+
+After a Mac reboot, the runner should start automatically via the LaunchAgent. To restart manually:
+
+```bash
+ssh alex@alexs-air.lan
+eval "$(/opt/homebrew/bin/brew shellenv)"
+gitlab-runner restart
+```
+
+If `gitlab-runner restart` reports "service not installed", reinstall:
+
+```bash
+gitlab-runner install
+gitlab-runner start
+```
+
+This rewrites the LaunchAgent plist.
+
+## Watching a CI job run live
+
+```bash
+ssh alex@alexs-air.lan 'tail -f ~/gitlab-runner.out.log'
+```
+
+The runner streams build output to stdout. The same output appears in the GitLab job UI.
+
+## Updating Xcode
+
+After a major Xcode update:
+
+```bash
+ssh alex@alexs-air.lan
+sudo xcodebuild -license accept     # accept the new license non-interactively
+xcode-select --install              # ensure command-line tools are present
+xcodebuild -version                 # confirm version
+```
+
+Then trigger a no-op tag rebuild (e.g. cut a patch release) to verify the runner still works.
+
+## Debugging fastlane locally
+
+If `build-ipa` fails in CI, reproduce on the Mac. The env vars below mirror what CI sets up:
+
+```bash
+ssh alex@alexs-air.lan
+cd ~/Projects/ditto
+git pull origin main
+eval "$(/opt/homebrew/bin/brew shellenv)"
+
+# Match what CI provides
+export CI_COMMIT_TAG=v2.x.y
+export CI_PIPELINE_IID=99999
+export MATCH_PASSWORD='<from GitLab CI variables>'
+export MATCH_GIT_BASIC_AUTHORIZATION='<base64 of ci-readonly:gldt-...>'
+export APP_STORE_CONNECT_API_KEY_ID=<key-id>
+export APP_STORE_CONNECT_API_KEY_ISSUER_ID=<issuer-id>
+export ASC_KEY_PATH=~/.private_keys/AuthKey_<key-id>.p8
+
+# Build web assets and sync to Capacitor iOS project (CI does this in before_script)
+npm ci
+npx vite build -l error
+cp dist/index.html dist/404.html
+npx cap sync ios
+node scripts/patch-cap-config.mjs
+
+# Stamp marketing version (CI does this in script)
+VERSION="${CI_COMMIT_TAG#v}"
+sed -i '' "s/MARKETING_VERSION = [0-9.]*;/MARKETING_VERSION = ${VERSION};/g" ios/App/App.xcodeproj/project.pbxproj
+
+# Run the build lane
+cd ios
+fastlane build_ipa
+```
+
+This produces the IPA at `../artifacts/Ditto.ipa` exactly like CI. Add `--verbose` for detailed output.
+
+To also test the submission step end-to-end (this calls Apple, so be ready to "Remove from Review" in App Store Connect afterward):
+
+```bash
+export IPA_PATH="$HOME/Projects/ditto/artifacts/Ditto.ipa"
+fastlane submit_release
+```
+
+Or, to debug *just* the submission against an already-uploaded build without rebuilding, use the `submit_only` lane (see "Debugging App Store submission with the `submit_only` lane" below).
+
+## Rotating match certificates (yearly)
+
+Apple distribution certs expire one year after issuance. To renew:
+
+```bash
+ssh alex@alexs-air.lan
+cd ~/Projects/ditto/ios
+eval "$(/opt/homebrew/bin/brew shellenv)"
+
+# Set Apple credentials (API key path)
+export MATCH_PASSWORD='<from GitLab CI variables>'
+
+# Revoke the expiring cert in Apple's portal and remove from the match repo
+fastlane match nuke distribution
+
+# Issue a new cert, generate a new App Store profile, encrypt, commit, push
+fastlane match appstore \
+  --api_key_path ~/.private_keys/AuthKey_<KEY_ID>.p8 \
+  --api_key_id <KEY_ID> \
+  --api_issuer_id <ISSUER_ID>
+```
+
+CI's next tag run picks up the new files via `match(... readonly: true)`. No GitLab variables to update.
+
+## Debugging App Store submission with the `submit_only` lane
+
+The `Fastfile` exposes a second lane, `submit_only`, that skips build/archive/upload and just runs `deliver` against an already-uploaded build. Useful when the binary is fine but the metadata/submission step is failing — iterate in ~30 seconds instead of waiting for a full ~6-minute CI build.
+
+```bash
+ssh alex@alexs-air.lan
+export PATH="$HOME/.gem/ruby/3.3.0/bin:/opt/homebrew/opt/ruby@3.3/bin:$PATH"
+cd ~/Projects/ditto/ios
+
+# Make sure the .p8 is on disk; CI's after_script wipes it after each job
+scp $LAPTOP:/path/to/AuthKey_<KEY_ID>.p8 ~/.private_keys/
+
+export ASC_KEY_PATH=$HOME/.private_keys/AuthKey_<KEY_ID>.p8
+export APP_STORE_CONNECT_API_KEY_ID=<KEY_ID>
+export APP_STORE_CONNECT_API_KEY_ISSUER_ID=<ISSUER_ID>
+export BUILD_NUMBER=<existing-build-number-on-ASC>
+export VERSION=<marketing-version, e.g. 2.14.3>
+
+fastlane submit_only
+```
+
+The lane expects the version to exist in App Store Connect with a `VALID` build attached. It uploads metadata (`./fastlane/metadata/en-US/release_notes.txt`) and calls `submit_for_review`. If Apple rejects, fix the Fastfile, re-run — no rebuild needed.
+
+If Apple has already accepted the submission for that version, you'll need to "Remove from Review" in App Store Connect (only available while state is `WAITING_FOR_REVIEW`, not `IN_REVIEW`) before re-running, or bump the build number.
+
+## Inspecting App Store Connect state directly
+
+When fastlane's error messages aren't enough, query Apple's API directly. There's no installed CLI — use the JWT signing recipe Apple documents. A working Ruby snippet lives in this skill's troubleshooting history; the short version:
+
+```ruby
+require "json"; require "openssl"; require "net/http"; require "base64"
+key_pem = File.read(ENV["ASC_KEY_PATH"])
+ec = OpenSSL::PKey::EC.new(key_pem)
+header = { alg: "ES256", kid: ENV["APP_STORE_CONNECT_API_KEY_ID"], typ: "JWT" }
+payload = { iss: ENV["APP_STORE_CONNECT_API_KEY_ISSUER_ID"], iat: Time.now.to_i, exp: Time.now.to_i + 1200, aud: "appstoreconnect-v1" }
+def b64(s); Base64.urlsafe_encode64(s, padding: false); end
+si = b64(JSON.generate(header)) + "." + b64(JSON.generate(payload))
+sig_der = ec.sign(OpenSSL::Digest::SHA256.new, si)
+asn = OpenSSL::ASN1.decode(sig_der)
+r = asn.value[0].value.to_s(2); s = asn.value[1].value.to_s(2)
+r = ("\x00".b * (32 - r.bytesize)) + r if r.bytesize < 32
+s = ("\x00".b * (32 - s.bytesize)) + s if s.bytesize < 32
+jwt = si + "." + b64(r + s)
+# Now: GET https://api.appstoreconnect.apple.com/v1/apps?filter[bundleId]=pub.ditto.app
+# with header Authorization: Bearer <jwt>
+```
+
+Useful endpoints:
+- `GET /v1/apps?filter[bundleId]=pub.ditto.app` → app id
+- `GET /v1/apps/<id>/appStoreVersions` → version list with `appStoreState`
+- `GET /v1/apps/<id>/builds?sort=-uploadedDate` → recent builds and processing state
+- `GET /v1/appStoreVersions/<id>/appStoreVersionLocalizations` → release notes (`whatsNew`)
+
+## What can go wrong
+
+| Symptom | Likely cause | Fix |
+|---|---|---|
+| Runner shows offline in GitLab | Mac rebooted, auto-login disabled, or LaunchAgent unloaded | SSH in, `gitlab-runner status`, `gitlab-runner restart` |
+| Build fails: "unable to find Xcode" | Xcode auto-updated and changed path, or command-line tools missing | `xcode-select --install`, `sudo xcodebuild -license accept` |
+| Build fails: "no signing certificate found" | match cert expired, was revoked manually, or `MATCH_PASSWORD` mismatched | Run yearly rotation procedure above |
+| Build fails: keychain locked / "User interaction is not allowed" | `setup_ci` failed to create the temporary keychain | Verify `FASTLANE_KEYCHAIN_PASSWORD` is set in GitLab CI variables |
+| Build fails: ASC API key invalid | Key was revoked or rotated | Generate a new key and update `APP_STORE_CONNECT_API_KEY_*` variables |
+| "Build already exists" from `deliver` | Previous tag's IPA had the same `CFBundleVersion`; fastlane's `increment_build_number` didn't bump because the value already matched `CI_PIPELINE_IID` | Push a new tag (each new tag has a new pipeline ID) |
+| Apple precheck rejects metadata | Encryption export compliance, IDFA, content rights flags don't match `Fastfile` | Update `submission_information` in `ios/fastlane/Fastfile` |
+| `OpenSSL::PKey::PKeyError: invalid curve name` | fastlane is running on brewed Ruby 4.0, which has a broken OpenSSL EC parser ([fastlane#20553](https://github.com/fastlane/fastlane/issues/20553)) | Use `ruby@3.3` from brew and install fastlane as a user gem (`gem install fastlane --user-install`); ensure `~/.bash_profile` puts `~/.gem/ruby/3.3.0/bin` on PATH ahead of `/opt/homebrew/bin` |
+| `gem install` / `bundle install` hangs for >30s per request | Ruby's net/http tries IPv6 to rubygems.org and times out on this network | `sudo networksetup -setv6off Wi-Fi` (per-interface, persistent until reboot) |
+| `Unresolved conflict between options: 'api_key_path' and 'api_key'` | `app_store_connect_api_key` action sets `APP_STORE_CONNECT_API_KEY_PATH` env var (path to `.p8`), match's same-named env var expects a JSON descriptor | Build the API key hash inline in the Fastfile (don't call `app_store_connect_api_key`); read `.p8` from a non-conflicting var like `ASC_KEY_PATH` |
+| `[match] Could not find the newly generated certificate installed` when running match interactively on macOS 26+ | [fastlane#15185](https://github.com/fastlane/fastlane/issues/15185) — the new-cert verification step trips on partition list and keychain trust | Run cert generation **in CI** via the bootstrap procedure in the `ci-cd-publishing` skill (uses `setup_ci`'s ephemeral keychain). Don't run `fastlane match appstore` interactively. |
+| iOS build fails: `No "iOS Development" signing certificate matching team ID` | The Xcode project uses `CODE_SIGN_STYLE=Automatic`; xcodebuild tries to find a Development cert even for Release builds | Override via `xcargs: "CODE_SIGN_STYLE=Manual CODE_SIGN_IDENTITY='Apple Distribution' PROVISIONING_PROFILE_SPECIFIER='match AppStore <bundle-id>' DEVELOPMENT_TEAM=<team>"` in the Fastfile (already configured) |
+| `vite.config.ts: Unexpected token 'c', "concurrent"... is not valid JSON` | GitLab Runner sets `CONFIG_FILE=/Users/alex/.gitlab-runner/config.toml` in the job environment, which collides with vite's `process.env.CONFIG_FILE ?? "./ditto.json"` lookup | Already fixed: use `DITTO_CONFIG_FILE` for the override env var |
+| `whatsNew is missing` from `submit_for_review` | `metadata_path: "./metadata"` resolves relative to fastlane's cwd (`ios/`), not its config dir (`ios/fastlane/`); fastlane silently uploads zero locales | Use `metadata_path: "./fastlane/metadata"` (already configured) |
+| `appStoreVersions ... is not in valid state` | Apple won't accept submission because the version is past `PREPARE_FOR_SUBMISSION` (already submitted, in review, or shipped) | "Remove from Review" in App Store Connect if `WAITING_FOR_REVIEW`, or cut a new version |
+| `An attribute value is not acceptable for the current resource state. - contentRightsDeclaration` | Apple rejects PATCH on locked App-level fields when `submission_information` includes `content_rights_*` | Drop `content_rights_*` from `submission_information` in the Fastfile (already configured) |
+
+## When the Mac dies
+
+1. Get a replacement Mac. Install Xcode from the App Store.
+2. Run the **`ci-cd-publishing`** skill's "Initial setup" — but skip the App Store Connect API key step (you already have it). Re-register the runner with the same `macos` tag.
+3. Restore signing identity: `cd ditto/ios && fastlane match appstore --readonly` decrypts the existing certs/profiles using `MATCH_PASSWORD`.
+4. No reissuance, no revocation, no GitLab variable updates needed. The certificates repo is the source of truth.

.agents/skills/nip19-routing/SKILL.md

@@ -0,0 +1,146 @@
+---
+name: nip19-routing
+description: Implement or populate the root-level NIP-19 router (/:nip19) that handles npub, nprofile, note, nevent, and naddr identifiers. Covers decoding, secure filter construction, and type-specific rendering for profiles, notes, events, and addressable events.
+---
+
+# NIP-19 Identifier Routing
+
+NIP-19 defines the bech32-encoded identifiers used throughout Nostr (`npub1...`, `note1...`, `naddr1...`, etc.). This project routes all of them through a single root-level page at `/:nip19`, implemented by `src/pages/NIP19Page.tsx`.
+
+Use this skill when the user wants to populate the `NIP19Page` sections with real views, add a new identifier type, or build links that point into the Nostr routing system.
+
+## Identifier Reference
+
+| Prefix       | Payload                                                          | Use when…                                                    |
+|--------------|------------------------------------------------------------------|--------------------------------------------------------------|
+| `npub1`      | 32-byte public key                                               | Simple user reference                                        |
+| `nprofile1`  | Public key + optional relay hints + petname                      | User reference with relay context                            |
+| `note1`      | 32-byte event ID (kind:1 text notes only, per NIP-10)            | Referencing a short text note/thread                         |
+| `nevent1`    | Event ID + optional relay hints + author pubkey + kind           | Any event kind, or notes where you need relay/author context |
+| `naddr1`     | `kind` + `pubkey` + `identifier` (`d` tag) + optional relay hints | Addressable events (kind 30000-39999): articles, products    |
+| `nsec1`      | Private key                                                      | **Never display or route** — treat as a 404                  |
+| `nrelay1`    | Relay URL                                                        | Deprecated                                                   |
+
+### `note1` vs `nevent1`
+
+- `note1` carries only an event ID, and is canonically tied to kind:1 text notes.
+- `nevent1` can reference **any** kind and can carry relay hints + author pubkey. Prefer `nevent1` for non-kind-1 events or when you want to ship relay hints with a link.
+
+### `npub1` vs `nprofile1`
+
+- `npub1` is just a pubkey.
+- `nprofile1` adds relay hints and a petname. Prefer it for shareable profile links where discoverability matters.
+
+## Routing Rules
+
+1. **All NIP-19 identifiers are handled at the URL root**: `/:nip19` in `AppRouter.tsx`. Never nest them under paths like `/note/:id` or `/profile/:npub`.
+2. **Invalid, vacant, or unsupported identifiers** (including `nsec1` and `nrelay1`) render the 404 page. The `NIP19Page` boilerplate already handles this.
+3. **Addressable event URLs must include the author**. `naddr1` already encodes `pubkey` + `kind` + `identifier`, which is exactly what a secure query filter needs. If you ever design an alternative URL, use the shape `/:npub/:dtag`, never `/:dtag` alone — otherwise anyone can publish a conflicting event with the same `d` tag.
+
+## Decoding and Filtering
+
+Nostr relay filters only accept hex strings. Always decode the NIP-19 identifier before building a filter.
+
+```ts
+import { nip19 } from 'nostr-tools';
+
+const decoded = nip19.decode(value); // throws on invalid input
+
+switch (decoded.type) {
+  case 'npub': {
+    const pubkey = decoded.data; // hex string
+    return nostr.query([{ kinds: [0], authors: [pubkey], limit: 1 }]);
+  }
+
+  case 'nprofile': {
+    const { pubkey /*, relays */ } = decoded.data;
+    return nostr.query([{ kinds: [0], authors: [pubkey], limit: 1 }]);
+  }
+
+  case 'note': {
+    const id = decoded.data;
+    return nostr.query([{ ids: [id], kinds: [1], limit: 1 }]);
+  }
+
+  case 'nevent': {
+    const { id /*, relays, author, kind */ } = decoded.data;
+    return nostr.query([{ ids: [id], limit: 1 }]);
+  }
+
+  case 'naddr': {
+    const { kind, pubkey, identifier } = decoded.data;
+    return nostr.query([{
+      kinds: [kind],
+      authors: [pubkey],        // critical: prevents d-tag spoofing
+      '#d': [identifier],
+      limit: 1,
+    }]);
+  }
+
+  default:
+    // nsec, nrelay, unknown → 404
+    throw new Error('Unsupported Nostr identifier');
+}
+```
+
+### Common mistakes
+
+```ts
+// ❌ Passing bech32 into a filter
+nostr.query([{ ids: [naddr] }]);
+
+// ❌ Addressable lookup without the author — anyone can spoof the d-tag
+nostr.query([{ kinds: [30023], '#d': [slug] }]);
+
+// ✅ Decode first, then include author
+const { kind, pubkey, identifier } = nip19.decode(naddr).data;
+nostr.query([{ kinds: [kind], authors: [pubkey], '#d': [identifier] }]);
+```
+
+## Populating `NIP19Page`
+
+`src/pages/NIP19Page.tsx` already:
+
+- Decodes `params.nip19` with `nip19.decode`.
+- Branches on `decoded.type` with a section for each supported identifier.
+- Redirects invalid / unsupported identifiers to the 404 page.
+- Provides a responsive container wrapper.
+
+To turn it into a real router, replace each placeholder section with a concrete component:
+
+| `decoded.type`        | Typical view                                                  |
+|-----------------------|---------------------------------------------------------------|
+| `npub` / `nprofile`   | Profile page: header from kind 0, feed of the user's events   |
+| `note`                | Single kind:1 text note with thread + replies                 |
+| `nevent`              | Generic event renderer; branch on `kind` for specialized UIs  |
+| `naddr`               | Addressable-event view (article, product, community, etc.)    |
+
+Inside each branch, pass the decoded payload (not the raw bech32 string) to a child component. That keeps filter construction colocated with the fetching hook and removes any chance of a re-decode mismatch.
+
+## Linking to NIP-19 Routes
+
+When building links elsewhere in the app:
+
+```tsx
+import { nip19 } from 'nostr-tools';
+import { Link } from 'react-router-dom';
+
+// To a profile
+<Link to={`/${nip19.npubEncode(pubkey)}`}>Profile</Link>
+
+// To an addressable event (article, product, …)
+<Link to={`/${nip19.naddrEncode({ kind, pubkey, identifier, relays })}`}>
+  Open
+</Link>
+
+// To a specific event of any kind, with relay hints
+<Link to={`/${nip19.neventEncode({ id, relays, author, kind })}`}>Open</Link>
+```
+
+Always encode with the **most specific** identifier you have context for (`nprofile` > `npub`, `nevent` > `note`, `naddr` for addressable). The extra metadata makes links more robust across relays.
+
+## Security Recap
+
+- Decode **before** querying.
+- For addressable events, always include `authors: [pubkey]` in the filter — the `d` tag alone is not a trust boundary.
+- Treat `nsec1` and any unknown/invalid identifier as 404. Never render, log, or echo a decoded `nsec`.

.agents/skills/nip85-stats/SKILL.md

@@ -0,0 +1,190 @@
+---
+name: nip85-stats
+description: Fetch pre-computed engagement stats (follower count, post count, reply count, reaction count, zap amounts, etc.) for users, events, and addressable events via a NIP-85 Trusted Assertion provider. Provides useNip85UserStats, useNip85EventStats, and useNip85AddrStats hooks backed by a configurable provider pubkey in AppConfig.
+---
+
+# NIP-85 Trusted Assertion Stats
+
+[NIP-85](https://github.com/nostr-protocol/nips/blob/master/85.md) defines "Trusted Assertions" — events published by a service provider that carry pre-computed stats (follower counts, reaction counts, zap totals, etc.) for users and events. Clients that would otherwise need to load thousands of events to compute these numbers can instead query a single addressable event from a trusted provider.
+
+This skill adds three hooks — `useNip85UserStats`, `useNip85EventStats`, `useNip85AddrStats` — and a configurable `nip85StatsPubkey` field on `AppConfig` so you can swap providers.
+
+## Kinds Used
+
+| Kind  | Subject                      | `d` tag value              |
+| ----- | ---------------------------- | -------------------------- |
+| 30382 | User                         | user pubkey (hex)          |
+| 30383 | Event (regular, kind 1 etc.) | event id (hex)             |
+| 30384 | Addressable event            | `<kind>:<pubkey>:<d-tag>`  |
+
+The hooks query one replaceable event at a time (`limit: 1`), filtered by `authors: [statsPubkey]` and `#d`. **Filtering by `authors` is required** — without it, anyone could publish a fake assertion with the same `d` tag and the client would accept it.
+
+## Files Provided by This Skill
+
+| Skill file | Copy to |
+|---|---|
+| `files/hooks/useNip85Stats.ts` | `src/hooks/useNip85Stats.ts` |
+
+## Setup Instructions
+
+### 1. Copy the Hooks File
+
+Copy `.agents/skills/nip85-stats/files/hooks/useNip85Stats.ts` into `src/hooks/useNip85Stats.ts`. It imports `@nostrify/react`, `@tanstack/react-query`, and `@/hooks/useAppContext`, all already present in the template.
+
+### 2. Add `nip85StatsPubkey` to `AppConfig`
+
+In `src/contexts/AppContext.ts`, add the field to the `AppConfig` interface:
+
+```typescript
+export interface AppConfig {
+  // ...existing fields...
+  /** Hex pubkey of the NIP-85 Trusted Assertion provider. Empty = disabled. */
+  nip85StatsPubkey: string;
+}
+```
+
+### 3. Update the Zod Schema in `AppProvider.tsx`
+
+In `src/components/AppProvider.tsx`, add the field to `AppConfigSchema`:
+
+```typescript
+const AppConfigSchema = z.object({
+  // ...existing fields...
+  nip85StatsPubkey: z.string().refine(
+    (val) => val.length === 0 || /^[0-9a-f]{64}$/i.test(val),
+    { message: 'Must be empty or a 64-character hex pubkey' },
+  ),
+}) satisfies z.ZodType<AppConfig>;
+```
+
+### 4. Set the Default in `App.tsx`
+
+Pick a provider pubkey and add it to `defaultConfig`. The ditto.pub provider is a reasonable default:
+
+```typescript
+const defaultConfig: AppConfig = {
+  // ...existing fields...
+  nip85StatsPubkey: '5f68e85ee174102ca8978eef302129f081f03456c884185d5ec1c1224ab633ea',
+};
+```
+
+Set to `''` to ship with stats disabled.
+
+### 5. Update `TestApp.tsx`
+
+In `src/test/TestApp.tsx`, add the field to the test default config. Use an empty string so tests don't hit a live provider:
+
+```typescript
+const defaultConfig: AppConfig = {
+  // ...existing fields...
+  nip85StatsPubkey: '',
+};
+```
+
+## Usage
+
+### User stats (kind 30382)
+
+```tsx
+import { useNip85UserStats } from '@/hooks/useNip85Stats';
+
+function FollowerCount({ pubkey }: { pubkey: string }) {
+  const { data: stats } = useNip85UserStats(pubkey);
+  if (!stats) return null; // no provider configured or no assertion yet
+  return <span>{stats.followers.toLocaleString()} followers</span>;
+}
+```
+
+### Event stats (kind 30383)
+
+```tsx
+import { useNip85EventStats } from '@/hooks/useNip85Stats';
+
+function NoteStats({ eventId }: { eventId: string }) {
+  const { data: stats } = useNip85EventStats(eventId);
+  if (!stats) return null;
+  return (
+    <div className="flex gap-3 text-sm text-muted-foreground">
+      <span>{stats.reactionCount} reactions</span>
+      <span>{stats.repostCount} reposts</span>
+      <span>{stats.commentCount} comments</span>
+      <span>{stats.zapAmount} sats</span>
+    </div>
+  );
+}
+```
+
+### Addressable event stats (kind 30384)
+
+The `addr` argument is the full NIP-01 event address `<kind>:<pubkey>:<d-tag>`:
+
+```tsx
+import { useNip85AddrStats } from '@/hooks/useNip85Stats';
+
+function ArticleStats({ kind, pubkey, identifier }: { kind: number; pubkey: string; identifier: string }) {
+  const { data: stats } = useNip85AddrStats(`${kind}:${pubkey}:${identifier}`);
+  if (!stats) return null;
+  return <span>{stats.reactionCount} reactions</span>;
+}
+```
+
+## Behavior Notes
+
+- **Graceful degradation:** The hooks return `null` (not an error) when `nip85StatsPubkey` is empty or the provider has no assertion for the subject. Always render defensively — NIP-85 is an optimization, not a source of truth.
+- **Short timeouts:** Each query is wrapped in a 2-second `AbortSignal.timeout` so a slow stats relay never blocks the UI.
+- **Cached by TanStack Query:** `staleTime` is 30s for event/addr stats and 60s for user stats. Results are keyed on `[kind, subject, statsPubkey]`, so swapping providers invalidates the cache automatically.
+- **Missing tags = 0:** A tag absent from the assertion is reported as `0` rather than `undefined`, matching NIP-85's "no data" semantics.
+- **Not the source of truth:** For interactive features (did *this* user like *this* post?) you still need to query the underlying reaction/zap/repost events. NIP-85 only provides aggregate counts.
+
+## Extending the Stats
+
+The hooks expose a small subset of the tags defined in NIP-85. To surface more (e.g. `zap_amt_sent`, `rank`, `first_created_at`), extend the return types and pull additional tags via `getIntTag`:
+
+```typescript
+export interface Nip85UserStats {
+  followers: number;
+  postCount: number;
+  rank: number;            // new
+  zapAmtReceived: number;  // new
+}
+
+// inside useNip85UserStats queryFn
+return {
+  followers: getIntTag(tags, 'followers'),
+  postCount: getIntTag(tags, 'post_cnt'),
+  rank: getIntTag(tags, 'rank'),
+  zapAmtReceived: getIntTag(tags, 'zap_amt_recd'),
+};
+```
+
+See the full tag table in [NIP-85](https://github.com/nostr-protocol/nips/blob/master/85.md).
+
+## Exposing a Provider Picker (Optional)
+
+If you want the user to change providers at runtime, add an input bound to `config.nip85StatsPubkey` and call `updateConfig` with a validated 64-char hex value:
+
+```tsx
+import { useAppContext } from '@/hooks/useAppContext';
+
+function StatsProviderInput() {
+  const { config, updateConfig } = useAppContext();
+  return (
+    <input
+      value={config.nip85StatsPubkey}
+      onChange={(e) => {
+        const v = e.target.value.trim().toLowerCase();
+        if (v === '' || /^[0-9a-f]{64}$/.test(v)) {
+          updateConfig(() => ({ nip85StatsPubkey: v }));
+        }
+      }}
+      placeholder="64-char hex pubkey (blank to disable)"
+    />
+  );
+}
+```
+
+## Related NIPs
+
+- [NIP-85](https://github.com/nostr-protocol/nips/blob/master/85.md) — Trusted Assertions (this skill)
+- [NIP-01](https://github.com/nostr-protocol/nips/blob/master/01.md) — Addressable event addressing (`<kind>:<pubkey>:<d-tag>`)
+- [NIP-57](https://github.com/nostr-protocol/nips/blob/master/57.md) — Zaps (the underlying events `zap_amount` / `zap_cnt` aggregate)

.agents/skills/nip85-stats/files/hooks/useNip85Stats.ts

@@ -0,0 +1,156 @@
+import { useNostr } from '@nostrify/react';
+import { useQuery } from '@tanstack/react-query';
+import { useAppContext } from '@/hooks/useAppContext';
+
+/** Engagement counts exposed by NIP-85 kind 30383 (events) and 30384 (addressable events). */
+export interface Nip85EventStats {
+  commentCount: number;
+  repostCount: number;
+  reactionCount: number;
+  zapCount: number;
+  /** Zap amount in sats. */
+  zapAmount: number;
+}
+
+/** A subset of NIP-85 kind 30382 (user) stats — extend as needed. */
+export interface Nip85UserStats {
+  followers: number;
+  postCount: number;
+}
+
+/**
+ * Read an integer tag value from a NIP-85 assertion event. Returns 0 when missing
+ * or unparseable, which mirrors the semantics of "no data" in NIP-85.
+ */
+function getIntTag(tags: string[][], tagName: string): number {
+  const tag = tags.find(([name]) => name === tagName);
+  if (!tag?.[1]) return 0;
+  const n = parseInt(tag[1], 10);
+  return Number.isFinite(n) ? n : 0;
+}
+
+/**
+ * Fetches NIP-85 event stats (kind 30383) from the configured stats pubkey.
+ * Returns `null` when no stats pubkey is configured or the provider has no
+ * assertion for this event.
+ */
+export function useNip85EventStats(eventId: string | undefined) {
+  const { nostr } = useNostr();
+  const { config } = useAppContext();
+  const statsPubkey = config.nip85StatsPubkey;
+
+  return useQuery<Nip85EventStats | null>({
+    queryKey: ['nip85-event-stats', eventId, statsPubkey],
+    queryFn: async ({ signal }) => {
+      if (!eventId || !statsPubkey) return null;
+
+      const combined = AbortSignal.any([signal, AbortSignal.timeout(2000)]);
+
+      try {
+        const events = await nostr.query(
+          [{ kinds: [30383], authors: [statsPubkey], '#d': [eventId], limit: 1 }],
+          { signal: combined },
+        );
+
+        if (events.length === 0) return null;
+
+        const { tags } = events[0];
+        return {
+          commentCount: getIntTag(tags, 'comment_cnt'),
+          repostCount: getIntTag(tags, 'repost_cnt'),
+          reactionCount: getIntTag(tags, 'reaction_cnt'),
+          zapCount: getIntTag(tags, 'zap_cnt'),
+          zapAmount: getIntTag(tags, 'zap_amount'),
+        };
+      } catch {
+        return null;
+      }
+    },
+    enabled: !!eventId && !!statsPubkey,
+    staleTime: 30 * 1000,
+    retry: false,
+  });
+}
+
+/**
+ * Fetches NIP-85 user stats (kind 30382) from the configured stats pubkey.
+ * Returns `null` when no stats pubkey is configured or the provider has no
+ * assertion for this pubkey.
+ */
+export function useNip85UserStats(pubkey: string | undefined) {
+  const { nostr } = useNostr();
+  const { config } = useAppContext();
+  const statsPubkey = config.nip85StatsPubkey;
+
+  return useQuery<Nip85UserStats | null>({
+    queryKey: ['nip85-user-stats', pubkey, statsPubkey],
+    queryFn: async ({ signal }) => {
+      if (!pubkey || !statsPubkey) return null;
+
+      const combined = AbortSignal.any([signal, AbortSignal.timeout(2000)]);
+
+      try {
+        const events = await nostr.query(
+          [{ kinds: [30382], authors: [statsPubkey], '#d': [pubkey], limit: 1 }],
+          { signal: combined },
+        );
+
+        if (events.length === 0) return null;
+
+        const { tags } = events[0];
+        return {
+          followers: getIntTag(tags, 'followers'),
+          postCount: getIntTag(tags, 'post_cnt'),
+        };
+      } catch {
+        return null;
+      }
+    },
+    enabled: !!pubkey && !!statsPubkey,
+    staleTime: 60 * 1000,
+    retry: false,
+  });
+}
+
+/**
+ * Fetches NIP-85 addressable event stats (kind 30384) from the configured
+ * stats pubkey. The `addr` argument is the full NIP-01 event address string,
+ * e.g. `30023:<pubkey>:<d-tag>`.
+ */
+export function useNip85AddrStats(addr: string | undefined) {
+  const { nostr } = useNostr();
+  const { config } = useAppContext();
+  const statsPubkey = config.nip85StatsPubkey;
+
+  return useQuery<Nip85EventStats | null>({
+    queryKey: ['nip85-addr-stats', addr, statsPubkey],
+    queryFn: async ({ signal }) => {
+      if (!addr || !statsPubkey) return null;
+
+      const combined = AbortSignal.any([signal, AbortSignal.timeout(2000)]);
+
+      try {
+        const events = await nostr.query(
+          [{ kinds: [30384], authors: [statsPubkey], '#d': [addr], limit: 1 }],
+          { signal: combined },
+        );
+
+        if (events.length === 0) return null;
+
+        const { tags } = events[0];
+        return {
+          commentCount: getIntTag(tags, 'comment_cnt'),
+          repostCount: getIntTag(tags, 'repost_cnt'),
+          reactionCount: getIntTag(tags, 'reaction_cnt'),
+          zapCount: getIntTag(tags, 'zap_cnt'),
+          zapAmount: getIntTag(tags, 'zap_amount'),
+        };
+      } catch {
+        return null;
+      }
+    },
+    enabled: !!addr && !!statsPubkey,
+    staleTime: 30 * 1000,
+    retry: false,
+  });
+}

.agents/skills/nostr-direct-messages/SKILL.md

@@ -1,478 +0,0 @@
----
-name: nostr-direct-messages
-description: Implement Nostr direct messaging features, build chat interfaces, or work with encrypted peer-to-peer communication (NIP-04 and NIP-17).
----
-
-# Direct Messaging on Nostr
-
-This project includes a complete direct messaging system supporting both NIP-04 (legacy) and NIP-17 (modern, more private) encrypted messages with real-time subscriptions, optimistic updates, and a persistent cache-first local storage.
-
-**The DM system is not enabled by default** - follow the setup instructions below to add messaging functionality to your application.
-
-## Setup Instructions
-
-### 1. Add DMProvider to Your App
-
-First, add the `DMProvider` to your app's provider tree in `src/App.tsx`:
-
-```tsx
-// Add these imports at the top of src/App.tsx
-import { DMProvider, type DMConfig } from '@/components/DMProvider';
-import { PROTOCOL_MODE } from '@/lib/dmConstants';
-
-// Add this configuration before your App component
-const dmConfig: DMConfig = {
-  // Enable or disable DMs entirely
-  enabled: true, // Set to true to enable messaging functionality
-
-  // Choose one protocol mode:
-  // PROTOCOL_MODE.NIP04_ONLY - Force NIP-04 (legacy) only
-  // PROTOCOL_MODE.NIP17_ONLY - Force NIP-17 (private) only
-  // PROTOCOL_MODE.NIP04_OR_NIP17 - Allow users to choose between NIP-04 and NIP-17 (defaults to NIP-17)
-  protocolMode: PROTOCOL_MODE.NIP17_ONLY, // Recommended for new apps
-};
-
-// Then wrap your app components with DMProvider:
-export function App() {
-  return (
-    <UnheadProvider head={head}>
-      <AppProvider storageKey="nostr:app-config" defaultConfig={defaultConfig}>
-        <QueryClientProvider client={queryClient}>
-          <NostrLoginProvider storageKey='nostr:login'>
-            <NostrProvider>
-              <NostrSync />
-              <DMProvider config={dmConfig}>
-                <TooltipProvider>
-                  <Toaster />
-                  <Suspense>
-                    <AppRouter />
-                  </Suspense>
-                </TooltipProvider>
-              </DMProvider>
-            </NostrProvider>
-          </NostrLoginProvider>
-        </QueryClientProvider>
-      </AppProvider>
-    </UnheadProvider>
-  );
-}
-```
-
-### 2. Configure DM Settings
-
-The `DMConfig` object supports the following options:
-
-- `enabled` (boolean, default: `false`) - Enable/disable entire DM system. When false, no messages are loaded, stored, or processed.
-- `protocolMode` (ProtocolMode, default: `PROTOCOL_MODE.NIP17_ONLY`) - Which protocols to support:
-  - `PROTOCOL_MODE.NIP04_ONLY` - Legacy encryption only
-  - `PROTOCOL_MODE.NIP17_ONLY` - Modern private messages (recommended)
-  - `PROTOCOL_MODE.NIP04_OR_NIP17` - Support both protocols (for backwards compatibility)
-
-**Note**: The DM system uses domain-based IndexedDB naming (`nostr-dm-store-${hostname}`) to prevent conflicts between multiple apps on the same domain.
-
-## Quick Start
-
-### 1. Send Messages
-
-```tsx
-import { useDMContext } from '@/hooks/useDMContext';
-import { MESSAGE_PROTOCOL } from '@/lib/dmConstants';
-
-function ComposeMessage({ recipientPubkey }: { recipientPubkey: string }) {
-  const { sendMessage } = useDMContext();
-  const [content, setContent] = useState('');
-
-  const handleSend = async () => {
-    await sendMessage({
-      recipientPubkey,
-      content,
-      protocol: MESSAGE_PROTOCOL.NIP17, // Uses NIP-44 encryption + gift wrapping
-    });
-    setContent('');
-  };
-
-  return (
-    <form onSubmit={(e) => { e.preventDefault(); handleSend(); }}>
-      <textarea
-        value={content}
-        onChange={(e) => setContent(e.target.value)}
-        placeholder="Type a message..."
-      />
-      <button type="submit">Send</button>
-    </form>
-  );
-}
-```
-
-### 2. Display Conversations
-
-```tsx
-import { useDMContext } from '@/hooks/useDMContext';
-import { useAuthor } from '@/hooks/useAuthor';
-import { genUserName } from '@/lib/genUserName';
-
-function ConversationList({ onSelectConversation }: { onSelectConversation: (pubkey: string) => void }) {
-  const { conversations, isLoading } = useDMContext();
-
-  if (isLoading) {
-    return <div>Loading conversations...</div>;
-  }
-
-  return (
-    <div className="space-y-2">
-      {conversations.map((conversation) => (
-        <ConversationItem
-          key={conversation.pubkey}
-          conversation={conversation}
-          onClick={() => onSelectConversation(conversation.pubkey)}
-        />
-      ))}
-    </div>
-  );
-}
-
-function ConversationItem({ conversation, onClick }: {
-  conversation: ConversationSummary;
-  onClick: () => void;
-}) {
-  const author = useAuthor(conversation.pubkey);
-  const displayName = author.data?.metadata?.name || genUserName(conversation.pubkey);
-  const avatarUrl = author.data?.metadata?.picture;
-
-  return (
-    <button onClick={onClick} className="w-full p-3 hover:bg-accent rounded-lg">
-      <div className="flex items-center gap-3">
-        <Avatar>
-          <AvatarImage src={avatarUrl} />
-          <AvatarFallback>{displayName.slice(0, 2).toUpperCase()}</AvatarFallback>
-        </Avatar>
-        <div className="flex-1 text-left">
-          <div className="font-medium">{displayName}</div>
-          <div className="text-sm text-muted-foreground truncate">
-            {conversation.lastMessage?.decryptedContent || 'No messages yet'}
-          </div>
-        </div>
-      </div>
-    </button>
-  );
-}
-```
-
-### 3. Display Messages in a Conversation
-
-```tsx
-import { useConversationMessages } from '@/hooks/useConversationMessages';
-import { useCurrentUser } from '@/hooks/useCurrentUser';
-
-function MessageThread({ conversationPubkey }: { conversationPubkey: string }) {
-  const { user } = useCurrentUser();
-  const { messages, hasMoreMessages, loadEarlierMessages } = useConversationMessages(conversationPubkey);
-
-  return (
-    <div className="flex flex-col space-y-2">
-      {hasMoreMessages && (
-        <button onClick={loadEarlierMessages} className="text-sm text-muted-foreground">
-          Load earlier messages
-        </button>
-      )}
-
-      {messages.map((message) => {
-        const isFromMe = message.pubkey === user?.pubkey;
-
-        return (
-          <div
-            key={message.id}
-            className={cn(
-              "flex",
-              isFromMe ? "justify-end" : "justify-start"
-            )}
-          >
-            <div className={cn(
-              "max-w-[70%] rounded-lg px-4 py-2",
-              isFromMe ? "bg-primary text-primary-foreground" : "bg-muted"
-            )}>
-              {message.error ? (
-                <span className="text-red-500">🔒 {message.error}</span>
-              ) : (
-                <p className="whitespace-pre-wrap break-words">
-                  {message.decryptedContent}
-                </p>
-              )}
-              {message.isSending && (
-                <span className="text-xs opacity-50">Sending...</span>
-              )}
-            </div>
-          </div>
-        );
-      })}
-    </div>
-  );
-}
-```
-
-## Using the Complete Messaging Interface
-
-For a fully-featured messaging UI out of the box, use the `DMMessagingInterface` component:
-
-```tsx
-import { DMMessagingInterface } from "@/components/dm/DMMessagingInterface";
-
-function MessagesPage() {
-  return (
-    <div className="container mx-auto p-4 h-screen">
-      <DMMessagingInterface />
-    </div>
-  );
-}
-```
-
-The `DMMessagingInterface` component provides a complete messaging UI with:
-- Conversation list with Active/Requests tabs
-- Message thread view with pagination
-- Compose area with file upload support
-- Real-time message updates
-- Mobile-responsive layout (shows one panel at a time on mobile)
-
-It requires no props and works automatically when wrapped in `DMProvider`.
-
-**For custom layouts**, see the "Building Custom Messaging UIs" section below for individual components (`DMConversationList`, `DMChatArea`, `DMStatusInfo`).
-
-## Sending Files with Messages
-
-```tsx
-import { useDMContext } from '@/hooks/useDMContext';
-import { useUploadFile } from '@/hooks/useUploadFile';
-import { MESSAGE_PROTOCOL } from '@/lib/dmConstants';
-import type { FileAttachment } from '@/contexts/DMContext';
-
-function ComposeWithFiles({ recipientPubkey }: { recipientPubkey: string }) {
-  const { sendMessage } = useDMContext();
-  const { mutateAsync: uploadFile, isPending: isUploading } = useUploadFile();
-  const [content, setContent] = useState('');
-  const [selectedFile, setSelectedFile] = useState<File | null>(null);
-
-  const handleSend = async () => {
-    let attachments: FileAttachment[] | undefined;
-
-    // Upload file if one is selected
-    if (selectedFile) {
-      const tags = await uploadFile(selectedFile);
-
-      attachments = [{
-        url: tags[0][1], // URL from first tag
-        mimeType: selectedFile.type,
-        size: selectedFile.size,
-        name: selectedFile.name,
-        tags: tags
-      }];
-    }
-
-    await sendMessage({
-      recipientPubkey,
-      content,
-      protocol: MESSAGE_PROTOCOL.NIP17,
-      attachments,
-    });
-
-    setContent('');
-    setSelectedFile(null);
-  };
-
-  return (
-    <form onSubmit={(e) => { e.preventDefault(); handleSend(); }}>
-      <textarea
-        value={content}
-        onChange={(e) => setContent(e.target.value)}
-        placeholder="Type a message..."
-      />
-
-      <input
-        type="file"
-        onChange={(e) => setSelectedFile(e.target.files?.[0] || null)}
-      />
-
-      {selectedFile && <div>Selected: {selectedFile.name}</div>}
-
-      <button type="submit" disabled={isUploading}>
-        {isUploading ? 'Uploading...' : 'Send'}
-      </button>
-    </form>
-  );
-}
-```
-
-## Protocol Comparison
-
-### NIP-04 (Legacy)
-- **Encryption**: NIP-04 (simpler, older)
-- **Metadata**: Sender and recipient visible to relays
-- **Event Kind**: Kind 4
-- **Use When**: Compatibility with older clients
-
-### NIP-17 (Modern & Private)
-- **Encryption**: NIP-44 (stronger)
-- **Metadata**: Hidden via gift wrapping (NIP-59)
-- **Event Kinds**: Kind 14 (text), Kind 15 (files)
-- **Wrapped In**: Kind 1059 (Gift Wrap) with ephemeral keys
-- **Use When**: Maximum privacy (recommended)
-
-**Key Privacy Features of NIP-17:**
-- Sender identity hidden (uses random ephemeral keys)
-- Timestamps randomized (±2 days) to hide send time
-- Dual gift wraps (recipient + sender) for message history
-
-## Advanced Features
-
-### Conversation Categorization
-
-The system automatically categorizes conversations:
-
-```tsx
-const { conversations } = useDMContext();
-
-// Filter by category
-const knownConversations = conversations.filter(c => c.isKnown);
-const requestConversations = conversations.filter(c => c.isRequest);
-
-// isKnown = true if user has sent at least one message
-// isRequest = true if only received messages, never replied
-```
-
-### Loading States
-
-```tsx
-const { isLoading, loadingPhase, scanProgress } = useDMContext();
-
-// Check overall loading state
-if (isLoading) {
-  console.log('Current phase:', loadingPhase);
-  // LOADING_PHASES.CACHE - Loading from local cache
-  // LOADING_PHASES.RELAYS - Querying relays
-  // LOADING_PHASES.SUBSCRIPTIONS - Setting up real-time updates
-  // LOADING_PHASES.READY - Fully loaded
-}
-
-// Display scan progress for large message histories
-if (scanProgress.nip17) {
-  console.log(`NIP-17: ${scanProgress.nip17.current} messages - ${scanProgress.nip17.status}`);
-}
-```
-
-### Clear Cache and Refresh
-
-```tsx
-import { useDMContext } from '@/hooks/useDMContext';
-
-function SettingsButton() {
-  const { clearCacheAndRefetch } = useDMContext();
-
-  const handleClearCache = async () => {
-    await clearCacheAndRefetch();
-    // Clears IndexedDB cache and reloads all messages from relays
-  };
-
-  return (
-    <button onClick={handleClearCache}>
-      Clear Message Cache
-    </button>
-  );
-}
-```
-
-## Architecture Notes
-
-### Data Flow
-1. **Cache First**: Messages load instantly from encrypted IndexedDB cache
-2. **Background Sync**: New messages fetched from relays in parallel
-3. **Real-time Updates**: WebSocket subscriptions for live messages
-4. **Optimistic UI**: Sent messages appear immediately, confirmed on relay response
-
-### Storage
-- **IndexedDB**: All messages stored locally with NIP-44 encryption
-- **Per-User Storage**: Separate encrypted store for each logged-in user
-- **Automatic Sync**: Debounced writes (15s) + immediate on new messages
-
-### Performance
-- **Parallel Queries**: NIP-04 and NIP-17 messages fetched simultaneously
-- **Batched Loading**: Messages loaded in batches (1000/batch, 20k limit)
-- **Pagination**: Conversation messages paginated (25/page)
-- **Deduplication**: Automatic filtering of duplicate messages by ID
-
-### Security
-- **NIP-44 Encryption**: Modern authenticated encryption for all NIP-17 messages
-- **Local Encryption**: IndexedDB storage encrypted with user's NIP-44 key
-- **Ephemeral Keys**: Random keys for NIP-17 gift wraps (sender anonymity)
-- **No Plaintext**: Decrypted content never persisted unencrypted
-- **Domain Isolation**: IndexedDB databases are namespaced by hostname to prevent data conflicts
-
-## Building Custom Messaging UIs
-
-For advanced use cases, you can use the individual DM components to build custom layouts:
-
-### Available Components
-
-**`DMConversationList`** - Conversation sidebar with tabs
-```tsx
-import { DMConversationList } from '@/components/dm/DMConversationList';
-
-<DMConversationList
-  selectedPubkey={selectedPubkey}
-  onSelectConversation={(pubkey) => setSelectedPubkey(pubkey)}
-  onStatusClick={() => setShowStatus(true)} // optional
-  className="h-full"
-/>
-```
-
-**`DMChatArea`** - Message thread and compose area
-```tsx
-import { DMChatArea } from '@/components/dm/DMChatArea';
-
-<DMChatArea
-  pubkey={selectedPubkey}
-  onBack={() => setSelectedPubkey(null)} // optional, for mobile back button
-  className="h-full"
-/>
-```
-
-**`DMStatusInfo`** - Debug/status panel
-```tsx
-import { DMStatusInfo } from '@/components/dm/DMStatusInfo';
-
-<DMStatusInfo clearCacheAndRefetch={clearCacheAndRefetch} />
-```
-
-### Custom Layout Example
-
-```tsx
-import { useState } from 'react';
-import { DMConversationList } from '@/components/dm/DMConversationList';
-import { DMChatArea } from '@/components/dm/DMChatArea';
-
-function CustomMessagingLayout() {
-  const [selectedPubkey, setSelectedPubkey] = useState<string | null>(null);
-
-  return (
-    <div className="flex h-screen">
-      {/* Custom sidebar */}
-      <aside className="w-64 border-r">
-        <DMConversationList
-          selectedPubkey={selectedPubkey}
-          onSelectConversation={setSelectedPubkey}
-        />
-      </aside>
-
-      {/* Custom main area */}
-      <main className="flex-1">
-        {selectedPubkey ? (
-          <DMChatArea pubkey={selectedPubkey} />
-        ) : (
-          <div className="flex items-center justify-center h-full">
-            <p>Select a conversation to start messaging</p>
-          </div>
-        )}
-      </main>
-    </div>
-  );
-}
-```
-

.agents/skills/nostr-encryption/SKILL.md

@@ -0,0 +1,81 @@
+---
+name: nostr-encryption
+description: Encrypt and decrypt content for Nostr direct messages, gift wraps, or any feature that needs NIP-44 (or legacy NIP-04) ciphertext, using the logged-in user's signer.
+---
+
+# Nostr Encryption and Decryption
+
+The logged-in user exposes a `signer` object that matches the NIP-07 signer interface. The signer handles all cryptographic operations internally — including ECDH, conversation-key derivation, and AEAD — so your code never touches a private key.
+
+**Always use the signer interface for encryption. Never ask the user for their private key, and never derive a shared secret yourself.**
+
+## NIP-44 (preferred)
+
+NIP-44 is the modern, authenticated encryption scheme used for DMs (NIP-17), gift wraps (NIP-59), and most new encrypted payloads.
+
+```ts
+import { useCurrentUser } from "@/hooks/useCurrentUser";
+
+function useEncryptedNote() {
+  const { user } = useCurrentUser();
+
+  if (!user) throw new Error("Must be logged in");
+
+  // Guard: older signers may not support NIP-44 yet.
+  if (!user.signer.nip44) {
+    throw new Error(
+      "Please upgrade your signer extension to a version that supports NIP-44 encryption",
+    );
+  }
+
+  // Encrypt a message to a recipient (use your own pubkey to encrypt to self).
+  const ciphertext = await user.signer.nip44.encrypt(
+    recipientPubkey,
+    "hello world",
+  );
+
+  // Decrypt a message from a sender (use the *other party's* pubkey).
+  const plaintext = await user.signer.nip44.decrypt(senderPubkey, ciphertext);
+
+  return plaintext;
+}
+```
+
+### Key points
+
+- `encrypt(peerPubkey, plaintext)` — `peerPubkey` is the **other party's** hex public key. For self-encryption (notes, backups), pass `user.pubkey`.
+- `decrypt(peerPubkey, ciphertext)` — `peerPubkey` is the author of the ciphertext you're decrypting (for an incoming DM, this is the sender's pubkey).
+- Both methods are async and may throw if the signer rejects the request or the ciphertext is malformed. Wrap calls in `try/catch`.
+- The signer handles conversation-key caching; repeated calls for the same peer are cheap.
+
+## NIP-04 (legacy)
+
+NIP-04 is only needed when interacting with older clients that haven't adopted NIP-44. The API mirrors NIP-44:
+
+```ts
+if (!user.signer.nip04) {
+  throw new Error("Signer does not support NIP-04");
+}
+
+const ciphertext = await user.signer.nip04.encrypt(peerPubkey, plaintext);
+const plaintext = await user.signer.nip04.decrypt(peerPubkey, ciphertext);
+```
+
+Prefer NIP-44 for anything new. Only fall back to NIP-04 when a spec or peer explicitly requires it.
+
+## Patterns
+
+### Encrypt-to-self (drafts, private notes)
+
+```ts
+const ciphertext = await user.signer.nip44.encrypt(user.pubkey, draft);
+createEvent({ kind: 30078, content: ciphertext, tags: [["d", "my-draft"]] });
+```
+
+### Decrypt an incoming DM (NIP-17 / NIP-59)
+
+For gift-wrapped DMs, you'll typically decrypt the outer wrap, then the inner seal, then read the rumor's content. Each decryption uses the *sender* of that specific layer as the peer pubkey.
+
+### Guarding the UI
+
+Always check `user.signer.nip44` (or `nip04`) before calling encryption methods. Remote signers and older browser extensions may not implement every interface, and catching the missing-capability case lets you show a useful message ("Please upgrade your signer") instead of an unhandled promise rejection.

.agents/skills/nostr-kind-design/SKILL.md

@@ -0,0 +1,89 @@
+---
+name: nostr-kind-design
+description: Decide whether to reuse an existing NIP or mint a new kind, design tag structures that relays can index, choose what goes in content vs. tags, and document new kinds or extensions in NIP.md. Load when authoring a new schema — not when wiring up rendering for a kind that already exists (use nostr-kind-rendering for that).
+---
+
+# Nostr Kinds — Design and Schema
+
+Load this skill when:
+
+- Minting a new event kind for a Ditto feature.
+- Extending an existing NIP with new tags.
+- Deciding whether an existing NIP covers a use case or whether a custom kind is warranted.
+- Documenting a custom kind or extension in `NIP.md`.
+
+**Not this skill** — if an existing NIP/kind covers your use case and you only need to render it in Ditto's UI, use the **`nostr-kind-rendering`** skill instead.
+
+## Choosing Between Existing NIPs and Custom Kinds
+
+1. **Thorough NIP review first.** Browse the NIP index, then read candidate NIPs in detail. The goal is to find the closest existing solution.
+2. **Prefer extending existing NIPs** over creating custom kinds, even at the cost of minor schema compromises. Custom kinds fragment the ecosystem.
+3. **When an existing NIP is close but not perfect**, use its kind as the base and add domain-specific tags. Document the extension in `NIP.md`.
+4. **Only mint a new kind** when no existing NIP covers the core functionality, the data structure is fundamentally different, or the use case requires different storage characteristics (regular vs. replaceable vs. addressable).
+5. **If a tool to generate a new kind number is available, you MUST call it.** Never pick an arbitrary number.
+6. **Custom kinds MUST include a NIP-31 `alt` tag** with a human-readable description of the event's purpose.
+
+**Example decision:**
+
+```
+Need: Equipment marketplace for farmers
+Options:
+  1. NIP-15 (Marketplace)   — too structured for peer-to-peer sales
+  2. NIP-99 (Classifieds)   — good fit, extensible with farming tags
+  3. Custom kind            — perfect fit, no interoperability
+
+Decision: NIP-99 + farming-specific tags.
+```
+
+## Kind Ranges
+
+An event's kind number determines storage semantics:
+
+- **Regular** (1000 ≤ kind < 10000) — stored permanently by relays. Notes, articles, etc.
+- **Replaceable** (10000 ≤ kind < 20000) — only the latest event per `pubkey+kind` is kept. Profile metadata, contact lists, mute lists.
+- **Addressable** (30000 ≤ kind < 40000) — identified by `pubkey+kind+d-tag`; only the latest per combo is kept. Long-form content, products, definitions.
+
+Kinds below 1000 are "legacy"; storage is per-kind (e.g. kind 1 is regular, kind 3 is replaceable).
+
+## Tag Design Principles
+
+- **Kind = schema, tags = semantics.** Don't mint a new kind just to represent a different category of the same data.
+- **Relays only index single-letter tags.** Use `t` for categories so filters like `'#t': ['electronics']` work at the relay level. Multi-letter tags (`product_type`, etc.) force inefficient client-side filtering.
+- **Filter at the relay**, not in JavaScript:
+
+  ```ts
+  // ❌ Fetch everything, filter locally
+  const events = await nostr.query([{ kinds: [30402] }]);
+  const filtered = events.filter((e) => hasTag(e, 'product_type', 'electronics'));
+
+  // ✅ Filter at the relay
+  const events = await nostr.query([{ kinds: [30402], '#t': ['electronics'] }]);
+  ```
+
+- **For Ditto-specific niches** (community apps, regional variants), tag events with a `t` value and query on it. Don't do this for generic platforms — it would silo content.
+
+## Content vs. Tags
+
+- **`content`** — large freeform text or existing industry-standard JSON (GeoJSON, FHIR, Tiled maps). Kind 0 is the one exception where structured JSON goes in content.
+- **Tags** — queryable metadata, structured data, anything you might filter on.
+- **Empty content is fine.** `content: ""` is idiomatic for tag-only events.
+- **If you need to filter by a field, it must be a tag** — relays don't index content.
+
+```json
+// ✅ Queryable
+{ "kind": 30402, "content": "",
+  "tags": [["d", "product-123"], ["title", "Camera"], ["price", "250"], ["t", "photography"]] }
+
+// ❌ Structured data buried in content
+{ "kind": 30402, "content": "{\"title\":\"Camera\",\"price\":250}", "tags": [["d", "product-123"]] }
+```
+
+## `NIP.md`
+
+`NIP.md` documents Ditto's custom kinds and any extensions to existing NIPs. Whenever you mint a new kind or change a custom schema, **create or update `NIP.md`** with the tag list, content format, and intended usage. If a kind you add is effectively the same shape as an existing NIP, note the NIP reference rather than duplicating the spec.
+
+Standard NIPs (like NIP-84 Highlights, NIP-23 Articles) do **not** go in `NIP.md` — only Ditto-custom kinds and Ditto-specific extensions.
+
+## After Designing — What's Next?
+
+Once you've settled on a kind number and tag shape, you still need to render it in Ditto's UI. Load the **`nostr-kind-rendering`** skill for the full multi-location registration checklist (feed cards, detail pages, embedded previews, kind-label maps, notifications, feed-toggle registration).

.agents/skills/nostr-kind-rendering/SKILL.md

@@ -0,0 +1,185 @@
+---
+name: nostr-kind-rendering
+description: Add UI rendering for an event kind Ditto doesn't yet display — feed cards, detail pages, embedded previews, notifications, routes, feed-toggle registration, and the several kind-label maps (KIND_LABELS, KIND_HEADER_MAP, NOTIFICATION_KIND_NOUNS, CommentContext) that must stay in sync. Load when asked to "support / display / render" a NIP or kind number, when a kind renders blank or as "Kind 12345", or when quote embeds of a kind show "This event kind is not supported".
+---
+
+# Nostr Kinds — UI Rendering Checklist
+
+Ditto's kind dispatch is **spread across many files** by design — feed cards, detail pages, embedded previews, notifications, and several kind-label maps each have their own rendering requirements. The central `KIND_LABELS` registry covers the easy cases, but most context-specific maps (grammar, icons, verbs) cannot be derived mechanically and must be updated manually.
+
+**Missing any location causes visible bugs**: a kind might render blank in quote posts, show "Kind 12345" as a label, skip its action header, tombstone as "This event kind is not supported" in embeds, or — worst of all — have its content fed through the kind-1 tokenizer and auto-linkify URLs/hashtags that weren't authored by the event creator.
+
+**When in doubt, grep for an existing kind number like `30617` or `9802`** — you'll find every registration point you need to mirror.
+
+## Decision: Feed-toggle + dedicated page, or just rendering?
+
+Before touching code, pick one:
+
+- **Just render it everywhere Nostr content appears** (no feed toggle, no dedicated page). Use when the kind is niche or only reached via direct links / quote embeds. Minimal surface — steps 1–6 below.
+- **Add a feed toggle + optional dedicated page.** Use when users should be able to browse events of this kind or opt them in/out of their home feed. Requires the feed registration (step 7) and `AppConfig` triple (step 8).
+
+When the user asks generally to "support" a kind, ask which direction they want if it's not obvious from context.
+
+## Checklist
+
+### 1. Content card component (`src/components/`)
+
+Create `<MyKindCard event={event} />` that renders the event's tags/content appropriately.
+
+- **Never run event content through the kind-1 tokenizer** (`<NoteContent>` / `<TruncatedNoteContent>`) unless the kind's content is actually free-form user prose. Quote-type content (highlights, snippets, citations) contains URLs and hashtags from the *source*, not the event author — tokenizing them is misleading.
+- Render plaintext with `whitespace-pre-wrap break-words` inside a `<p>` instead.
+- Route any event-sourced URLs (`r` tags, media URLs, source links) through `sanitizeUrl()` from `@/lib/sanitizeUrl` before using them in `href`/`src`.
+- Support an `expanded` prop if the card looks different on the detail page than in the feed.
+
+### 2. Feed card dispatch (`src/components/NoteCard.tsx`)
+
+Three edits in this file:
+
+1. **Flag block** (around lines 384–435): add `const isMyKind = event.kind === XXXX;`.
+2. **`isTextNote` negation list** (around lines 440–475): add `&& !isMyKind`. Without this, unknown kinds fall through to `UnknownKindContent` (showing only the `alt` tag).
+3. **Content dispatch ternary** (around lines 578–692): add `) : isMyKind ? (<MyKindCard event={event} />`.
+4. **`KIND_HEADER_MAP`** (around lines 1710+): add an entry so the feed shows "Alice shared a *noun*" or similar. Pattern:
+   ```ts
+   9802: {
+     icon: Highlighter,
+     action: "shared a",
+     noun: "highlight",
+     nounRoute: "/highlights",  // omit if no dedicated page
+   },
+   ```
+5. Import the card component and any new lucide icons.
+
+### 3. Detail page dispatch (`src/pages/PostDetailPage.tsx`)
+
+Mirror the three NoteCard edits:
+
+1. **Flag block** (around lines 1021–1098): `const isMyKind = event.kind === XXXX;`.
+2. **`isTextNote` negation list**: add `&& !isMyKind`.
+3. **Content dispatch ternary** (around lines 2147–2251): add `) : isMyKind ? (<MyKindCard event={event} expanded />`.
+
+The loading-state title uses `shellTitleForKind()`, which falls through to `KIND_LABELS` — no override needed unless the kind belongs to a group ("Music Details") or needs composite grammar.
+
+### 4. Central kind label (`src/lib/kindLabels.ts`)
+
+Add a **capitalized noun phrase, no articles** to the `KIND_LABELS` map:
+
+```ts
+9802: 'Highlight',
+```
+
+This is consumed by the detail-page loading title, nsite permission prompt, signer nudge toasts, and addressable-event preview headers. Ignoring this gives "Kind 9802" everywhere it appears.
+
+### 5. Context-specific label and icon maps
+
+Each of these maps exists because the surrounding UI needs a different grammatical form. They are **not derived** from `KIND_LABELS` and must be updated manually.
+
+- **`src/components/CommentContext.tsx`** — `KIND_LABELS` (uses articles: `'a highlight'`, `'an article'`) and `KIND_ICONS` (lucide component reference). Rendered as "Commenting on {label}". Without an entry you get "an unsupported event".
+- **`src/pages/NotificationsPage.tsx`** — `NOTIFICATION_KIND_NOUNS` (bare lowercase nouns: `'highlight'`, `'article'`). Rendered as "reacted to your {noun}". Without an entry you get "post" as a fallback.
+- **`src/components/NoteCard.tsx`** — `KIND_HEADER_MAP` (already covered in step 2).
+
+### 6. Embedded previews (`src/components/EmbeddedNote.tsx`)
+
+The quote-embed dispatcher in `EmbeddedNote` (around lines 65–110) routes kinds to dedicated compact cards. **Without a branch here, non-content kinds fall through to `EmbeddedNoteCard`, which either:**
+
+- Shows only the NIP-31 `alt` tag (if present), or
+- Tombstones as "This event kind is not supported", or
+- **Feeds the event's `content` through the kind-1 tokenizer** if the kind is mistakenly treated as a content-kind — auto-linkifying URLs and hashtags that weren't authored by the event creator. This is a security/UX bug.
+
+For any kind whose `content` isn't freeform user prose, add an explicit dispatch branch even if it just renders a minimal compact card. Pattern:
+
+```tsx
+if (event.kind === 9802) {
+  return <EmbeddedHighlightCard event={event} className={className} disableHoverCards={disableHoverCards} />;
+}
+```
+
+Then define the compact card using `EmbeddedCardShell` for the author row + navigation, and render the kind-specific body inside. See `EmbeddedHighlightCard` and `EmbeddedBadgeAwardCard` for reference.
+
+`src/components/EmbeddedNaddr.tsx` works similarly for addressable kinds — add a branch there if your kind is addressable.
+
+### 7. Feed/sidebar registration (`src/lib/extraKinds.ts`)
+
+Only needed if you decided on "feed-toggle + dedicated page" above. Add an `ExtraKindDef`:
+
+```ts
+{
+  kind: 9802,
+  id: 'highlights',
+  showKey: 'showHighlights',
+  feedKey: 'feedIncludeHighlights',
+  label: 'Highlights',
+  description: 'Noteworthy excerpts from articles, posts, and the web (NIP-84)',
+  route: 'highlights',          // omit for feed-only registration
+  addressable: false,
+  section: 'social',            // feed | media | social | development | whimsy
+  blurb: 'Longer marketing copy shown in the info modal.',
+},
+```
+
+Then:
+
+- **Sidebar icon** (`src/lib/sidebarItems.tsx`) — add `{ id: "highlights", label: "Highlights", path: "/highlights", icon: Highlighter }` to `SIDEBAR_ITEMS`, and import the icon at the top. `CONTENT_KIND_ICONS` picks up the icon automatically from the sidebar definition.
+- **Route** (`src/AppRouter.tsx`) — add `const highlightsDef = getExtraKindDef("highlights")!;` at the top of the file and a `<Route path="/highlights" element={<KindFeedPage kind={highlightsDef.kind} title={highlightsDef.label} icon={sidebarItemIcon("highlights", "size-5")} />} />` above the catch-all `*` route.
+
+### 8. `AppConfig` triple (required if you added feed/sidebar toggle keys in step 7)
+
+Three files must stay in sync, or the build fails or the setting silently no-ops:
+
+1. **`src/contexts/AppContext.ts`** — add the fields to the `FeedSettings` interface with JSDoc comments.
+2. **`src/lib/schemas.ts`** — add the same fields to `FeedSettingsSchema` as `z.boolean().optional()`. `DittoConfigSchema` is derived from `AppConfigSchema` with `.strict()` mode, so any `ditto.json` field missing from Zod is a build error.
+3. **`src/App.tsx`** — add the default value in the initial `feedSettings` block.
+4. **`src/test/TestApp.tsx`** — mirror the default in test config so component tests work.
+
+Convention: `show*` toggles default to `true` (sidebar entries visible), `feedInclude*` toggles default to `false` for niche content, `true` for core feed content.
+
+### 9. Notification integration (if applicable)
+
+Load this step when the kind represents an interaction with the user's content (reactions, reposts, highlights, awards, etc.) — i.e. when an event author "does something with" another user's content via an `e`/`a`/`p` tag.
+
+**Six files** to update:
+
+1. **`src/hooks/useEncryptedSettings.ts`** — add `highlights?: boolean` (or equivalent) to the `notificationPreferences` object.
+2. **`src/lib/notificationKinds.ts`** — add the kind to `ALL_NOTIFICATION_KINDS` and add a `if (p.X !== false) kinds.push(XXXX);` line in `getEnabledNotificationKinds`.
+3. **`src/lib/notificationTemplates.ts`** — add a `NOTIFICATION_TEMPLATES` entry with a title and body for nostr-push server-side notifications.
+4. **`src/pages/NotificationSettings.tsx`** — extend `NotificationPrefKey` union, add a row to `NOTIFICATION_TYPES` with icon/label/description/kinds.
+5. **`src/hooks/useNotifications.ts`** — extend `groupKey` (decide if events of this kind group by referenced event or stand alone), and if it's a "did something to your content" kind, add it to the author-ownership filter so users only get notified for interactions with their own content.
+6. **`src/pages/NotificationsPage.tsx`** — add a case to `GroupedNotificationView`'s switch; write `MyKindNotification` + `MyKindNotificationGroup` components modeled on `RepostNotification` / `LikeNotification`.
+
+### 10. Spam guards (`src/lib/feedUtils.ts`)
+
+If the kind has required tags (NIP-spec-mandated references, minimum content, etc.), add a check in `shouldHideFeedEvent` to hide events that don't meet the minimum bar. This pre-filters events before `NoteCard` mounts them, avoiding layout shifts from components that would return `null`.
+
+Example:
+
+```ts
+// NIP-84 highlights with no excerpt AND no source reference.
+if (event.kind === 9802) {
+  const hasContent = event.content.trim().length > 0;
+  const hasSource = event.tags.some(([n]) => n === 'a' || n === 'e' || n === 'r');
+  if (!hasContent && !hasSource) return true;
+}
+```
+
+### 11. `NIP.md` (custom kinds only)
+
+If the kind is a Ditto-custom kind or a Ditto-specific extension of an existing NIP, document it in `NIP.md` — see the **`nostr-kind-design`** skill for the format. Standard NIPs (like NIP-84, NIP-23) do not go in `NIP.md`.
+
+## Validation
+
+After making changes, run `npm run test` — it runs `tsc --noEmit`, `eslint`, `vitest`, and `vite build` in sequence. All must pass. Additions to the `AppConfig` triple in particular frequently break the build if one of the four files is missed.
+
+## Why so many locations?
+
+These are genuinely different UI contexts (feed cards, detail pages, embedded previews, comment-context labels, notifications, sidebar routes) with different rendering requirements and grammar needs. The central `KIND_LABELS` in `src/lib/kindLabels.ts` handles the common "what to call this kind" case, but feed headers, comment-context text, and notification verbs each need their own grammar, and notification integration involves a whole independent subsystem.
+
+## Bugs that signal a missed step
+
+- **"Kind 12345" shown as a label** → step 4 (`KIND_LABELS`).
+- **"an unsupported event" in CommentContext** → step 5 (`CommentContext` maps).
+- **"reacted to your **post**"** when it should say "highlight" → step 5 (`NOTIFICATION_KIND_NOUNS`).
+- **No action header above a feed card** → step 2.4 (`KIND_HEADER_MAP`).
+- **Blank / `alt`-only card in quote embeds** → step 6 (`EmbeddedNote` dispatcher).
+- **URLs/hashtags in quoted text auto-linkified** → step 6 (embedded dispatcher forgot to bypass the kind-1 tokenizer).
+- **Kind doesn't appear in the home feed even with the toggle on** → step 7 (`ExtraKindDef` missing `feedKey`).
+- **Build error mentioning a missing `FeedSettings` field** → step 8 (one of the three files out of sync).
+- **Users not notified when their content is interacted with** → step 9 (notification stack).

.agents/skills/nostr-publishing/SKILL.md

@@ -0,0 +1,115 @@
+---
+name: nostr-publishing
+description: Publish Nostr events with useNostrPublish. Covers the basic publishing pattern, safely mutating replaceable and addressable events (read-modify-write via fetchFreshEvent + prev), published_at preservation, and d-tag collision prevention for new addressable content.
+---
+
+# Publishing Nostr Events
+
+Use this skill when a feature needs to publish events — notes, reactions, list updates, profile edits, addressable content, etc. Covers the `useNostrPublish` hook, the correct read-modify-write pattern for replaceable/addressable lists, and d-tag collision prevention.
+
+## The `useNostrPublish` Hook
+
+`useNostrPublish` publishes an event through the app's connection pool and auto-adds a `client` tag. Always guard calls with `useCurrentUser` — publishing requires a signer.
+
+```tsx
+import { useCurrentUser } from '@/hooks/useCurrentUser';
+import { useNostrPublish } from '@/hooks/useNostrPublish';
+
+export function PostForm() {
+  const { user } = useCurrentUser();
+  const { mutate: createEvent } = useNostrPublish();
+
+  if (!user) return <span>You must be logged in to post.</span>;
+
+  return (
+    <button onClick={() => createEvent({ kind: 1, content: 'hello' })}>
+      Post
+    </button>
+  );
+}
+```
+
+Prefer `mutateAsync` over `mutate` when the caller needs to `await` the published event (e.g. to navigate to the new event's page, or to chain another publish).
+
+## Mutating Replaceable and Addressable Events (CRITICAL)
+
+Replaceable (kind 10000-19999) and addressable (kind 30000-39999) events require a **read-modify-write** cycle: fetch the current event, modify its tags, publish a new version. **Never read from the TanStack Query cache before mutating** — the cache can be stale from another device or a rapid prior operation, and republishing stale data silently drops the user's data.
+
+Use `fetchFreshEvent()` from `src/lib/fetchFreshEvent.ts` inside every mutation, and **always pass the fetched event as `prev`** so `useNostrPublish` can preserve `published_at`:
+
+```typescript
+import { fetchFreshEvent } from '@/lib/fetchFreshEvent';
+
+// Inside a mutation function:
+const prev = await fetchFreshEvent(nostr, {
+  kinds: [10003],
+  authors: [user.pubkey],
+});
+const currentTags = prev?.tags ?? [];
+// ...modify tags...
+await publishEvent({
+  kind: 10003,
+  content: prev?.content ?? '',
+  tags: newTags,
+  prev: prev ?? undefined,
+});
+```
+
+This applies to all list-type hooks (bookmarks, pins, interests, follow sets, badges, etc.). See `useFollowActions` and `useMuteList` for complete examples.
+
+### The `prev` Property on Event Templates
+
+`useNostrPublish` accepts an optional `prev` property on the event template — the **previous version** of the event being replaced. The hook uses it to manage the `published_at` tag (NIP-24) automatically:
+
+- **First publish (no `prev`)** — `published_at` is set equal to `created_at`.
+- **Update (`prev` provided)** — `published_at` is preserved from the old event.
+- **Old event lacks `published_at`** — nothing is fabricated.
+- **Caller already set `published_at` in tags** — left alone.
+
+**Convention**: name the local variable `prev` at the call site (not `freshEvent` or `latestEvent`) so it reads naturally when passed to `publishEvent`:
+
+```typescript
+const prev = await fetchFreshEvent(nostr, { kinds: [3], authors: [user.pubkey] });
+// ...
+await publishEvent({ kind: 3, content: prev?.content ?? '', tags: newTags, prev: prev ?? undefined });
+```
+
+`prev` is stripped from the template before signing — it never appears in the published Nostr event.
+
+## D-Tag Collision Prevention for Addressable Events
+
+Addressable events (kind 30000-39999) are identified by `pubkey + kind + d-tag`. Publishing an event with the same d-tag as an existing one **silently replaces** it. This is by design for intentional updates (edit flows), but dangerous when creating *new* content with user-derived d-tags (slugs from titles, user-entered identifiers, etc.).
+
+### When to check for collisions
+
+- **Must check** when the d-tag is derived from user input (slugified titles, user-entered identifiers, etc.).
+- **No check needed** when the d-tag is a `crypto.randomUUID()`, a canonical format with an embedded pubkey prefix, or intentionally the same as an existing event (edit/update flows).
+
+### Implementation pattern
+
+Before publishing a **new** addressable event with a user-derived d-tag, query for an existing event with that d-tag. If one exists, block the publish and tell the user to change the identifier.
+
+```typescript
+// Before publishing a new addressable event:
+const slug = slugify(title, { lower: true, strict: true });
+
+const existing = await nostr.query([
+  { kinds: [30023], authors: [user.pubkey], '#d': [slug], limit: 1 },
+]);
+
+if (existing.length > 0) {
+  toast({
+    title: 'Slug already in use',
+    description: 'Change the slug or edit the existing item.',
+    variant: 'destructive',
+  });
+  return;
+}
+
+// Safe to publish
+publishEvent({ kind: 30023, content, tags: [['d', slug], ...otherTags] });
+```
+
+**Skip the check in edit mode** — when the user explicitly loaded an existing event to update, overwriting is the intended behavior.
+
+Prefer UUID or canonical formats when the d-tag doesn't need to be human-readable. Only use slugified input when the d-tag will appear in URLs or needs to be meaningful to users, and always add a collision check.

.agents/skills/nostr-queries/SKILL.md

@@ -0,0 +1,117 @@
+---
+name: nostr-queries
+description: Query Nostr events efficiently with useNostr + TanStack Query. Covers the standard useQuery pattern, combining related kinds into a single request to avoid rate limiting, and validating events with required tags or strict schemas.
+---
+
+# Querying Nostr Events
+
+Use this skill when building a hook that fetches Nostr events. Covers the standard `useNostr` + `useQuery` pattern, efficient query design (combining kinds to avoid relay round-trips), and event validation for kinds with required tags.
+
+## The Standard Pattern
+
+Combine `useNostr` with TanStack Query in a custom hook. Pass the abort signal from `c.signal` into `nostr.query` so cancelled queries free relay resources:
+
+```typescript
+import { useNostr } from '@nostrify/react';
+import { useQuery } from '@tanstack/react-query';
+
+function usePosts() {
+  const { nostr } = useNostr();
+
+  return useQuery({
+    queryKey: ['posts'],
+    queryFn: async (c) => {
+      const events = await nostr.query(
+        [{ kinds: [1], limit: 20 }],
+        { signal: c.signal },
+      );
+      return events;
+    },
+  });
+}
+```
+
+Transform events into a domain model inside the `queryFn` if needed — callers should rarely see raw `NostrEvent`s. Multiple calls to `nostr.query()` inside one `queryFn` are fine for compound queries that can't be expressed as a single filter.
+
+## Efficient Query Design
+
+**Always minimize the number of separate round-trips** to relays. Each query consumes relay capacity and may count against rate limits.
+
+**✅ Efficient — single query with multiple kinds:**
+
+```typescript
+// Query repost variants in one request
+const events = await nostr.query([{
+  kinds: [1, 6, 16],
+  '#e': [eventId],
+  limit: 150,
+}]);
+
+// Separate by kind in JavaScript
+const notes = events.filter((e) => e.kind === 1);
+const reposts = events.filter((e) => e.kind === 6);
+const genericReposts = events.filter((e) => e.kind === 16);
+```
+
+**❌ Inefficient — three separate round-trips:**
+
+```typescript
+const [notes, reposts, genericReposts] = await Promise.all([
+  nostr.query([{ kinds: [1], '#e': [eventId] }]),
+  nostr.query([{ kinds: [6], '#e': [eventId] }]),
+  nostr.query([{ kinds: [16], '#e': [eventId] }]),
+]);
+```
+
+### Optimization rules
+
+1. **Combine kinds** into one filter: `kinds: [1, 6, 16]`.
+2. **Use multiple filter objects** in a single `nostr.query()` call when different tag filters are needed simultaneously.
+3. **Raise the `limit`** when combining kinds so you still receive enough of each type.
+4. **Split by kind in JavaScript**, not by making separate requests.
+5. **Respect relay capacity** — heavy parallel queries can trigger rate limits even when each individually would be fine.
+
+## Event Validation
+
+For kinds with required tags or strict schemas (most custom kinds, anything beyond kind 1), filter query results through a validator before returning them. Loose kinds (kind 1 text notes) rarely need validation — all tags are optional and `content` is freeform.
+
+```typescript
+import type { NostrEvent } from '@nostrify/nostrify';
+
+// Example validator for NIP-52 calendar events
+function validateCalendarEvent(event: NostrEvent): boolean {
+  if (![31922, 31923].includes(event.kind)) return false;
+
+  const d = event.tags.find(([n]) => n === 'd')?.[1];
+  const title = event.tags.find(([n]) => n === 'title')?.[1];
+  const start = event.tags.find(([n]) => n === 'start')?.[1];
+  if (!d || !title || !start) return false;
+
+  // Date-based events require YYYY-MM-DD
+  if (event.kind === 31922 && !/^\d{4}-\d{2}-\d{2}$/.test(start)) return false;
+
+  // Time-based events require a unix timestamp
+  if (event.kind === 31923) {
+    const ts = parseInt(start);
+    if (isNaN(ts) || ts <= 0) return false;
+  }
+
+  return true;
+}
+
+function useCalendarEvents() {
+  const { nostr } = useNostr();
+  return useQuery({
+    queryKey: ['calendar-events'],
+    queryFn: async (c) => {
+      const events = await nostr.query(
+        [{ kinds: [31922, 31923], limit: 20 }],
+        { signal: c.signal },
+      );
+      return events.filter(validateCalendarEvent);
+    },
+  });
+}
+```
+
+Validation is a correctness layer, not a security layer. For trust-sensitive queries (admin actions, addressable events, moderator approvals), also constrain `authors` — see the `nostr-security` skill.

.agents/skills/nostr-relay-pools/SKILL.md

@@ -0,0 +1,92 @@
+---
+name: nostr-relay-pools
+description: Query or publish to specific Nostr relays or curated relay groups using nostr.relay() and nostr.group(), instead of the default connection pool. Useful for debugging, testing, specialized relays, or geographically-targeted publishing.
+---
+
+# Targeted Nostr Relay Connections
+
+By default, the `nostr` object returned from `useNostr` uses the app's connection pool: it reads from one of the configured relays and publishes to all of them. For most features this is exactly what you want.
+
+Use this skill when you need **more granular control** — talking to a single relay, a curated group of relays, or debugging a specific relay's behavior.
+
+## Single Relay: `nostr.relay(url)`
+
+```ts
+import { useNostr } from '@nostrify/react';
+
+function useSpecificRelay() {
+  const { nostr } = useNostr();
+
+  // Connect to a specific relay
+  const relay = nostr.relay('wss://relay.damus.io');
+
+  // Query from this relay only
+  const events = await relay.query([{ kinds: [1], limit: 15 }]);
+
+  // Publish to this relay only
+  await relay.event({ kind: 1, content: 'Hello from a specific relay!' });
+}
+```
+
+**Good fits:**
+
+- Testing a relay's behavior in isolation
+- Debugging connectivity or rate-limiting issues
+- Querying content that only lives on a specialized relay (paid relays, private relays, niche communities)
+- Health checks / admin tooling
+
+## Relay Group: `nostr.group(urls)`
+
+```ts
+import { useNostr } from '@nostrify/react';
+
+function useRelayGroup() {
+  const { nostr } = useNostr();
+
+  // Create a group of specific relays
+  const relayGroup = nostr.group([
+    'wss://relay.damus.io',
+    'wss://relay.primal.net',
+    'wss://nos.lol',
+  ]);
+
+  // Query from all relays in the group (deduplicated)
+  const events = await relayGroup.query([{ kinds: [1], limit: 15 }]);
+
+  // Publish to all relays in the group
+  await relayGroup.event({ kind: 1, content: 'Hello from a relay group!' });
+}
+```
+
+**Good fits:**
+
+- Publishing to a curated set of trusted relays for a specific feature
+- Community-scoped queries (e.g. a set of relays known to host a particular topic)
+- Geographic/region-targeted delivery
+- Load-balancing reads across a known-good subset
+
+## API Consistency
+
+Both the `relay` object and the `group` object expose the **same interface** as the top-level `nostr` object:
+
+- `.query(filters, opts?)` — request events matching filters
+- `.req(filters, opts?)` — open a streaming subscription
+- `.event(event)` — publish a signed event
+- All other Nostrify methods
+
+This means you can drop them into any existing hook or helper that expects a `nostr`-shaped object.
+
+## Choosing Between Pool, Group, and Single Relay
+
+| Scenario                                           | Use                 |
+|----------------------------------------------------|---------------------|
+| Default app queries, best reach for publishing     | `nostr` (pool)      |
+| Trusted subset, community-specific publishing      | `nostr.group([…])`  |
+| Single-relay debugging or specialized relay access | `nostr.relay(url)`  |
+
+## Tips
+
+- **Don't hard-code user-facing relay lists.** If a feature should publish to "the user's write relays", read from `AppContext.config.relayMetadata` (NIP-65) instead of hard-coding URLs.
+- **Compose with TanStack Query.** Wrap `relay.query(...)` / `group.query(...)` inside a `useQuery` hook exactly as you would with the default `nostr` object; the caching layer is identical.
+- **Handle unreachable relays.** Specific relays can be offline, rate-limited, or slow. Always wrap calls in `try/catch` and respect the abort signal from the query function (`c.signal`).
+- **Avoid leaking subscriptions.** When using `.req(...)` for streaming, always close the subscription on unmount (`controller.abort()` or the returned disposer).

.agents/skills/nostr-security/SKILL.md

@@ -0,0 +1,140 @@
+---
+name: nostr-security
+description: Threat model and defenses for Ditto as a web Nostr client — why XSS is catastrophic when nsec keys live in localStorage, CSP as defense-in-depth, URL and CSS sanitization for untrusted event data, and author filtering for trust-sensitive queries (admin actions, moderators, addressable events, NIP-72 communities). Load when building trust-boundary features, rendering user-controlled URLs or markup, interpolating event data into CSS, or reviewing the app's security posture.
+---
+
+# Nostr Security
+
+## Threat model
+
+**Nostr private keys (`nsec`) are stored in plaintext in `localStorage`.** Any JavaScript running on the origin can read them with `localStorage.getItem('nostr-login')`. A successful XSS = instant, silent, irreversible key theft — no rotation, no revocation, permanent impersonation across every Nostr client the user ever touches. External signers (NIP-07 extension, NIP-46 bunker) don't change this: an XSS can still ask the active signer to sign arbitrary events, drain funds via zaps, or scrape DMs as they decrypt.
+
+**Treat every piece of untrusted data as a script-injection vector** — event tags, `content`, metadata, URL params, relay responses.
+
+## Defense-in-depth
+
+**Content Security Policy.** `index.html` ships a restrictive CSP: `default-src 'none'`, `script-src 'self'` (no inline scripts, no `eval`), `base-uri 'self'`, `connect-src 'self' https: wss:`. The one intentional gap is `style-src 'unsafe-inline'` — required by Tailwind/shadcn — which means **CSS injection is not blocked by CSP; sanitization is on you**. When modifying CSP, only narrow it. Never add `'unsafe-eval'`, `'unsafe-inline'` on `script-src`, `http:`, or wildcard sources.
+
+**Never use `dangerouslySetInnerHTML`, `innerHTML`, `insertAdjacentHTML`, or `document.write`** with event data, URL params, or any other untrusted string. React's JSX auto-escapes interpolated strings — the moment you bypass that, CSP alone won't save you. If you must render HTML from event data, pipe it through a strict allowlist sanitizer (DOMPurify, already installed) at the parse layer.
+
+**Sanitize URLs and CSS values** — see §1 and §2.
+
+## 1. URL sanitization
+
+Any URL from event tags, `content`, metadata fields (`picture`, `banner`, `website`, `nip05`, etc.), or relay hints is untrusted. Threats beyond `javascript:` XSS: `data:` resource exhaustion / phishing, `http://` IP leaks, relative paths triggering same-origin requests, malformed strings crashing downstream parsers.
+
+**Use the shipped helper at `src/lib/sanitizeUrl.ts`:**
+
+```ts
+import { sanitizeUrl } from '@/lib/sanitizeUrl';
+
+// Single URL — returns the normalised href, or undefined if not valid https
+const url = sanitizeUrl(getTag(event.tags, 'url'));
+if (url) {
+  // safe to use in any context
+}
+
+// Array of URLs — filter out invalid entries
+const links = getAllTags(event.tags, 'r')
+  .map(([, v]) => sanitizeUrl(v))
+  .filter((v): v is string => !!v);
+```
+
+`sanitizeUrl` returns the normalised `href` string only when the URL parses successfully **and** uses the `https:` protocol. All other inputs (malformed URLs, `javascript:`, `data:`, `http:`, relative paths, etc.) return `undefined`.
+
+**Sanitize at the parse layer.** When writing a parser function that extracts URLs from event tags (e.g. `parseThemeDefinition`, `parseBadgeDefinition`), apply `sanitizeUrl()` before returning the parsed data. This way every downstream consumer is automatically protected without needing to remember to sanitize at each usage site.
+
+**When sanitization is NOT required:** URLs matched by a regex that constrains the protocol (e.g. `NoteContent`'s tokenizer matching `https?://...` — the regex *is* the sanitizer), hardcoded/app-generated URLs (relay configs, internal routes), and strings rendered as plain text that never land in an attribute, CSS value, or network request.
+
+## 2. CSS injection
+
+Event data interpolated into CSS (a `<style>` element, `style=""`, or an injected stylesheet) is a CSS injection vector. A `"`, `)`, `}`, or `;` in the value can break out of the string context and inject rules — overlay phishing, hide UI, exfiltrate via `background-image: url()` requests.
+
+Common surfaces: `background-image: url("${url}")`, `font-family: "${family}"`, `@font-face { src: url("${url}") }`.
+
+**Mitigation:**
+
+- **URLs in `url()`** — use `sanitizeUrl()`. The `URL` constructor percent-encodes `"`, `)`, `\` and rejects non-`https:`. This is already done for theme event background and font URLs in `src/lib/themeEvent.ts`.
+- **Non-URL strings** (font-family, animation names) — use `sanitizeCssString()` from `src/lib/fontLoader.ts`, which allowlists Unicode letters/numbers, spaces, hyphens, underscores, apostrophes, and periods:
+
+```ts
+import { sanitizeUrl } from '@/lib/sanitizeUrl';
+import { sanitizeCssString } from '@/lib/fontLoader';
+
+// ❌ UNSAFE
+style.textContent = `body { background-image: url("${rawUrl}"); font-family: "${rawFamily}"; }`;
+
+// ✅ SAFE — validate URLs, allowlist identifiers
+const bgUrl = sanitizeUrl(rawUrl);
+const family = sanitizeCssString(rawFamily ?? '');
+if (bgUrl && family) {
+  style.textContent = `body { background-image: url("${bgUrl}"); font-family: "${family}"; }`;
+}
+```
+
+If you can't justify the exact characters you're allowing, the policy is wrong.
+
+## 3. Author filtering for trust-sensitive queries
+
+Even with perfect XSS defenses, an attacker can publish forged events your UI will trust unless queries constrain `authors`. Relays are dumb pipes — any matching event comes back.
+
+**Filter by `authors` when:**
+
+- Querying admin/moderator/owner events — use a hardcoded trusted-pubkey list (e.g. `ADMIN_PUBKEYS` from `src/lib/admins`).
+- Querying addressable events (kinds 30000–39999) — the `d` tag alone is not a trust boundary; the `(kind, pubkey, d)` triple is.
+- Querying user-owned replaceable events (profile metadata, relay lists, mute lists) — `authors: [userPubkey]`.
+
+**Do NOT filter by `authors`** for public UGC (kind 1 notes, reactions, zaps, discovery feeds) — anyone can post there by design.
+
+```ts
+// ❌ Anyone can publish kind 30078 with this d-tag and self-appoint
+nostr.query([{ kinds: [30078], '#d': ['pathos-organizers'], limit: 1 }]);
+
+// ✅ Only trust the admin list
+nostr.query([{ kinds: [30078], authors: ADMIN_PUBKEYS, '#d': ['pathos-organizers'], limit: 1 }]);
+```
+
+**Routes for addressable/replaceable events must include the author** — otherwise the route handler can't construct a secure filter:
+
+```tsx
+// ❌ Any pubkey can squat the slug
+<Route path="/article/:slug" element={<Article />} />
+// ✅ Filter can include authors
+<Route path="/article/:npub/:slug" element={<Article />} />
+```
+
+### NIP-72 community moderation
+
+Kind 4550 approvals are only trustworthy if signed by a moderator from the community definition (kind 34550). Two-step query:
+
+```ts
+// 1. Fetch community definition — author-filter by the owner.
+const [community] = await nostr.query([{
+  kinds: [34550], authors: [communityOwnerPubkey], '#d': [communityId], limit: 1,
+}]);
+if (!community) return [];
+
+// 2. Extract moderator pubkeys from `p` tags with role "moderator".
+const moderators = community.tags
+  .filter(([n, , , role]) => n === 'p' && role === 'moderator')
+  .map(([, pubkey]) => pubkey);
+
+// 3. Query approvals — only from moderators.
+const approvals = await nostr.query([{
+  kinds: [4550],
+  authors: moderators,
+  '#a': [`34550:${communityOwnerPubkey}:${communityId}`],
+  limit: 100,
+}]);
+```
+
+Without step 3's `authors` filter, anyone can publish a kind 4550 "approval".
+
+## Pre-merge checklist
+
+- [ ] No `dangerouslySetInnerHTML` / `innerHTML` / `document.write` with untrusted data.
+- [ ] CSP unchanged or narrowed; no new `'unsafe-eval'`, `'unsafe-inline'` on `script-src`, `http:`, or wildcards.
+- [ ] Every event-sourced URL passes `sanitizeUrl()` before reaching `href`, `src`, `srcSet`, `poster`, iframe `src`, or CSS.
+- [ ] Every event-sourced string in CSS passes `sanitizeUrl()` (URLs) or `sanitizeCssString()` (identifiers).
+- [ ] Every trust-sensitive query includes `authors`.
+- [ ] Routes for addressable/replaceable events carry the author in the URL.

.agents/skills/release/SKILL.md

@@ -87,6 +87,8 @@ Prepend a new section to `CHANGELOG.md` directly below the `# Changelog` heading
 ```markdown
 ## [X.Y.Z] - YYYY-MM-DD
 
+A short single-paragraph summary of this release written in plain prose -- max 500 characters. This appears on the App Store, Google Play, and the in-app "what's new" toast.
+
 ### Added
 - Description of new features
 
@@ -100,7 +102,100 @@ Prepend a new section to `CHANGELOG.md` directly below the `# Changelog` heading
 - Description of removed features
 ```
 
-**Rules:**
+#### The Summary Paragraph
+
+Every release section MUST start with a single plaintext paragraph (not a bullet, not a heading) that summarises the release for app-store-style audiences:
+
+- **Single paragraph, plain prose.** No bullets, no headings, no Markdown formatting beyond plain text.
+- **Max ~500 characters.** Apple App Store and Google Play both cap "What's new" text at 500. The CI `release-notes` job warns when the summary is longer.
+- **Audience: end users discovering the update.** Describe the most noticeable user-visible changes; omit internal cleanups even if they're in the bullets below.
+- **Tone matches the bullets.** Present-tense, no Nostr jargon, no NIP/kind numbers (see Rules below).
+- **Maintenance releases** -- write a one-sentence summary like `A behind-the-scenes maintenance release with no user-facing changes.` Don't leave it blank; the CI fallback `Ditto vX.Y.Z` is a last resort for legacy entries, not new ones.
+
+The same paragraph is used in three places automatically:
+- **App Store** -- "What's New in This Version" via fastlane `deliver`
+- **Google Play** -- "What's new in this version" via fastlane `supply` `metadata/android/<lang>/changelogs/<versionCode>.txt`
+- **In-app toast** -- the `What's new in vX.Y.Z` toast that fires when users load a new version (see `src/components/VersionCheck.tsx`)
+- The full section (summary + lists) goes into the GitLab Release description.
+
+Extraction is handled by `scripts/extract-release-notes.mjs`; you don't have to write store-specific copy.
+
+#### Changelog Quality Checklist
+
+Before drafting any entries, run through this checklist. It is NOT optional -- skipping steps here is the most common way a release goes out with misleading notes.
+
+##### 5.1. Diff the code, not just the commit log
+
+Commit messages describe intent at the moment of commit; they over- and under-represent the cumulative effect at release time. Before drafting entries, **run a real diff** for each area of substantial change:
+
+```bash
+# Full diff between tags
+git diff v<prev>..HEAD
+
+# Or narrowed to an area you're unsure about
+git diff v<prev>..HEAD -- src/components/ComposeBox.tsx
+```
+
+Only the diff reveals intra-release churn (commits that cancel each other out, bugs introduced and then fixed, refactors that land and get reverted). Reading commit messages alone is insufficient.
+
+##### 5.2. Trace every candidate "Fixed" entry to its origin commit
+
+For each bug fix you're considering listing, find the commit that introduced the bug.
+
+**Fast path -- check for `Regression-of:` trailers** (see AGENTS.md "Attributing Regressions"). If the fix commit declares its origin in a trailer, you don't need to hunt:
+
+```bash
+# List all commits in the release window with their Regression-of trailers (if any)
+git log v<prev>..HEAD --no-merges \
+  --format='%h %s%n  Regression-of: %(trailers:key=Regression-of,valueonly,separator=%x20)'
+```
+
+For each `Regression-of: <sha>` entry, check whether `<sha>` is also in the release window:
+
+```bash
+# Returns 0 if <sha> is BEFORE v<prev> (pre-existing bug -> legit "Fixed" entry)
+# Returns non-zero if <sha> is AFTER v<prev> (intra-release -> omit from "Fixed")
+git merge-base --is-ancestor <sha> v<prev>
+```
+
+**Fallback -- manual tracing** (when no trailer is present):
+
+```bash
+# Show the history of a file across all commits
+git log --oneline v<prev>..HEAD -- path/to/file.tsx
+
+# Or blame the specific lines the fix touched
+git blame -L <start>,<end> -- path/to/file.tsx
+```
+
+**If the introducing commit is also in this release window (i.e. after the previous tag), the bug is intra-release.** The user on the previous version never experienced it. Do NOT list it as a "Fixed" entry. Fold it into the relevant "Added" or "Changed" entry, or omit it entirely.
+
+##### 5.3. The "Would a user on the previous version notice this?" test
+
+The changelog describes the delta between the previous release and this one **from the user's perspective** -- not the development history. Before writing each entry, ask:
+
+> "Did a user on the previous published version experience this exact thing?"
+
+- If they experienced a broken state that is now fixed: **"Fixed" entry**
+- If they experienced the old behavior and now see new behavior: **"Changed" or "Added" entry**
+- If they never saw either state (introduced AND resolved within this release window): **omit entirely**
+
+This applies to more than just bugs:
+- A feature added and then reverted in the same release: omit both
+- A refactor that was done and then undone: omit both
+- A performance regression introduced and then fixed: omit both
+- A typo introduced in a new string and then corrected: mention the new string (if user-facing) as a single "Added"/"Changed" entry, with no "Fixed" entry
+
+##### 5.4. Worked example -- intra-release bug
+
+> **Scenario:** Commit A overhauls the compose box and, as a side effect, breaks the background of the expanded emoji picker. Commit B, later in the same release window, restores the background.
+>
+> **Correct changelog:** One "Added" entry describing the compose box overhaul. The emoji picker background is part of the finished state the user receives.
+>
+> **Incorrect changelog:** An "Added" entry for the overhaul AND a "Fixed" entry for the emoji picker background. The user on the previous version never saw the broken background; listing it invents a problem they didn't have and makes the release notes read like a developer changelog.
+
+#### Rules
+
 - Only include categories that have entries (omit empty categories)
 - Write **user-facing descriptions**, not raw commit messages
 - Keep descriptions concise -- one line per change
@@ -109,9 +204,9 @@ Prepend a new section to `CHANGELOG.md` directly below the `# Changelog` heading
 - Focus on what the user sees/experiences, not internal implementation details
 - Use the current date in YYYY-MM-DD format
 - **Never use Nostr protocol jargon.** NIP numbers (e.g., "NIP-89", "NIP-17"), kind numbers (e.g., "kind 30078"), and other protocol-level references must not appear in the changelog. Describe the feature in plain language from the user's perspective. For example, write "App cards for Nostr apps" instead of "App cards for Nostr apps (NIP-89)". The changelog audience is end users, not protocol developers.
-- **Collapse related work into one entry.** If a feature was added and then fixed/tweaked across multiple commits in the same release, present the finished result as a single "Added" entry. Never list something as "Added" and then also list fixes for that same thing -- the user sees the end product, not the development history.
+- **Only ship what the user sees.** If a bug was introduced AND fixed within this release, the user never saw it -- omit the fix entirely (or fold the net result into the relevant Added/Changed entry). The same applies to features that were added and reverted, refactors that cancel out, and any other intra-release churn. See the Changelog Quality Checklist above (especially 5.2 and 5.3) for the procedure to verify this.
+- **Collapse related work into one entry.** If a feature was added and then tweaked across multiple commits in the same release, present the finished result as a single "Added" entry. Never list something as "Added" and then also list fixes for that same thing -- the user sees the end product, not the development history.
 - **Omit purely internal changes.** CI fixes, build pipeline tweaks, developer tooling, and infrastructure changes should be omitted from the changelog entirely unless they have a direct, visible impact on the user experience. The changelog is for users, not developers.
-- **Compare the actual code between versions** to understand what really changed, rather than just reading commit messages. Commit messages may over- or under-represent the significance of changes.
 
 ### Step 6: Update Version in All Files
 
@@ -190,8 +285,12 @@ git push origin main vX.Y.Z
 
 This triggers the GitLab CI pipeline which will:
 1. Build a signed Android APK and AAB
-2. Create a GitLab Release with download links
-3. Publish the APK to Zapstore
+2. Build a signed iOS IPA on the self-hosted Mac runner
+3. Extract release notes (full body + summary paragraph) from `CHANGELOG.md`
+4. Create a GitLab Release with APK / AAB / IPA download links
+5. Publish the APK to Zapstore
+6. Publish the AAB to Google Play (production track) with the summary as the "What's new" text
+7. Submit the iOS IPA to App Store Connect for review with the summary as the "What's New" text
 
 ### Step 12: Confirm
 
@@ -212,11 +311,15 @@ After pushing, inform the user:
 
 ## CI Pipeline
 
-The CI pipeline (`.gitlab-ci.yml`) is triggered by tags matching the pattern `/^v\d+\.\d+\.\d+$/` (e.g., `v2.1.0`). It runs three jobs:
+The CI pipeline (`.gitlab-ci.yml`) is triggered by tags matching the pattern `/^v\d+\.\d+\.\d+$/` (e.g., `v2.1.0`). It runs seven jobs:
 
 1. **build-apk**: Builds signed Android APK and AAB, stamps `versionName` and `versionCode` into the build
-2. **release**: Creates a GitLab Release with the changelog content and download links
-3. **publish-zapstore**: Publishes the APK to Zapstore
+2. **build-ipa**: Builds the signed App Store IPA on the self-hosted Mac runner (`tags: [macos]`); stamps `MARKETING_VERSION` and `CFBundleVersion` into the Xcode project. The IPA is uploaded to GitLab's Generic Packages registry and exposed as a CI artifact for downstream jobs
+3. **release-notes**: Extracts the version's changelog section and summary paragraph from `CHANGELOG.md` into two artifacts (`release-notes.md` and `release-notes-summary.txt`) consumed by `release`, `publish-app-store`, and `publish-google-play`
+4. **release**: Creates a GitLab Release with the full changelog section and APK / AAB / IPA download links
+5. **publish-zapstore**: Publishes the APK to Zapstore
+6. **publish-google-play**: Uploads the AAB to Google Play production track and writes the release summary to `metadata/android/en-US/changelogs/<versionCode>.txt`
+7. **publish-app-store**: Submits the prebuilt IPA to App Store Connect for review with the release summary as the "What's New" text. Runs on the self-hosted Mac runner (`tags: [macos]`) because `fastlane deliver` shells out to Apple's iTMSTransporter to upload the IPA, and that tool only ships inside Xcode — the previous Linux runner crashed at the upload step with `No such file or directory @ dir_chdir0` because `Helper.itms_path` resolved to a missing Xcode path. The build appears in App Store Connect within ~30 minutes; Apple's human review then takes 24-48 hours typically. Once approved, you must release manually in App Store Connect (`automatic_release: false`) — this is the final human gate. For runner operations, match cert rotation, and debugging, load the **`mac-runner`** skill.
 
 ## Troubleshooting
 

.agents/skills/testing/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: testing
+description: Write Vitest unit tests for React components and hooks using the project's `TestApp` wrapper, jsdom environment, and pre-mocked browser APIs (localStorage, matchMedia, scrollTo, IntersectionObserver, ResizeObserver). Also covers the project policy on when to create new test files.
+---
+
+# Testing
+
+Load this skill when the user asks you to write a test, diagnose a bug with a test, or add coverage for a component/hook. Running the existing test script is a standing requirement (see `AGENTS.md` → *Validating Your Changes*) and doesn't require this skill.
+
+## Policy: when to create new test files
+
+**Do not create new test files unless one of these applies:**
+
+1. The user explicitly asks for tests.
+2. The user describes a specific bug and asks for tests to diagnose it.
+3. The user says a problem persists after you tried to fix it.
+
+Never write tests because tool results show failures, because you think tests would be helpful, or because you added a new feature. The request must come from the user.
+
+If none of the above apply, stop — don't create a test file. Keep running the existing test script as usual.
+
+## Test setup
+
+The project uses **Vitest + jsdom** with **React Testing Library** and **jest-dom** matchers. Global setup lives in `src/test/setup.ts` and mocks these browser APIs that jsdom doesn't provide (or that Node's built-ins conflict with):
+
+- `localStorage` — a Map-backed mock, because Node 22's built-in `localStorage` lacks the Web Storage API surface jsdom expects
+- `window.matchMedia`
+- `window.scrollTo`
+- `IntersectionObserver`
+- `ResizeObserver`
+
+If your component needs another browser API, extend `src/test/setup.ts` rather than mocking per-file.
+
+## Writing a component test
+
+Wrap rendered components in `TestApp` (`src/test/TestApp.tsx`) so all context providers — `UnheadProvider`, `AppProvider`, `QueryClientProvider`, `NostrLoginProvider`, `NostrProvider`, `BrowserRouter`, etc. — are available. Without it, hooks like `useQuery`, `useNostr`, `useAppContext`, or `useNavigate` will throw.
+
+```tsx
+import { describe, it, expect } from 'vitest';
+import { render, screen } from '@testing-library/react';
+import { TestApp } from '@/test/TestApp';
+import { MyComponent } from './MyComponent';
+
+describe('MyComponent', () => {
+  it('renders correctly', () => {
+    render(<TestApp><MyComponent /></TestApp>);
+    expect(screen.getByText('Expected text')).toBeInTheDocument();
+  });
+});
+```
+
+## Writing a hook test
+
+Use `renderHook` from `@testing-library/react` and pass `TestApp` as the `wrapper`:
+
+```tsx
+import { describe, it, expect } from 'vitest';
+import { renderHook, waitFor } from '@testing-library/react';
+import { TestApp } from '@/test/TestApp';
+import { useMyHook } from './useMyHook';
+
+describe('useMyHook', () => {
+  it('returns expected data', async () => {
+    const { result } = renderHook(() => useMyHook(), { wrapper: TestApp });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toBeDefined();
+  });
+});
+```
+
+Files placed next to the code under test with the `.test.ts` / `.test.tsx` suffix are picked up automatically. For reference, see `src/test/ErrorBoundary.test.tsx`.
+
+## Running tests
+
+The `npm test` script runs `tsc --noEmit`, `eslint`, `vitest run`, and `vite build` in sequence. Always run it after changes — a passing test file alone doesn't mean your task is done.
+
+For fast iteration, run just Vitest:
+
+```bash
+npx vitest run
+```
+
+Or in watch mode while editing:
+
+```bash
+npx vitest
+```

.agents/skills/theming/SKILL.md

@@ -0,0 +1,127 @@
+---
+name: theming
+description: Customize Ditto's visual design — install Google Fonts via @fontsource, change the color scheme, configure light/dark themes, and apply consistent component styling patterns with Tailwind and CSS variables.
+---
+
+# Theming, Fonts, and Color Schemes
+
+Use this skill when the user wants to change fonts, colors, light/dark appearance, or general visual styling. Ditto ships with a light/dark theme system built on CSS custom properties and Tailwind v3, plus a `useTheme` hook for runtime switching.
+
+## Adding Fonts
+
+Any Google Font can be installed via the `@fontsource` / `@fontsource-variable` packages.
+
+1. **Install the font package.** Prefer the variable version when available.
+   ```bash
+   npm install @fontsource-variable/inter
+   ```
+   Package naming:
+   - `@fontsource-variable/<font-name>` — variable fonts (preferred; one file, all weights)
+   - `@fontsource/<font-name>` — static fonts
+
+2. **Import the font once** in `src/main.tsx`:
+   ```ts
+   import '@fontsource-variable/inter';
+   ```
+
+3. **Register the family** in `tailwind.config.ts`:
+   ```ts
+   export default {
+     theme: {
+       extend: {
+         fontFamily: {
+           sans: ['Inter Variable', 'Inter', 'system-ui', 'sans-serif'],
+         },
+       },
+     },
+   };
+   ```
+
+### Suggested families by use case
+
+- **Modern / Clean:** Inter Variable, Outfit Variable, Manrope
+- **Professional / Corporate:** Roboto, Open Sans, Source Sans Pro
+- **Creative / Artistic:** Poppins, Nunito, Comfortaa
+- **Monospace / Code:** JetBrains Mono, Fira Code, Source Code Pro
+
+For expressive hierarchies, pair a sans body font with a display/serif heading font (e.g. Inter + Playfair Display) and expose the second family as `fontFamily.serif` or `fontFamily.display` in Tailwind.
+
+### Runtime font loading from Nostr events
+
+Ditto also supports loading fonts referenced from Nostr events (theme events, letter stationery, etc.) through `src/lib/fontLoader.ts`. That path is separate from the build-time `@fontsource` approach — it constructs `@font-face` rules at runtime from sanitized URLs. Never feed event data through the `@fontsource` path; always go through `fontLoader` so the URL and family name are passed through `sanitizeUrl()` and `sanitizeCssString()` (see the `nostr-security` skill).
+
+## Color Schemes
+
+Colors are defined as CSS custom properties in `src/index.css` under two selectors:
+
+- `:root` — light-mode values
+- `.dark` — dark-mode overrides
+
+When the user requests a new color scheme:
+
+1. **Update both `:root` and `.dark`** in `src/index.css`. Each variable is an HSL triplet (no `hsl()` wrapper), e.g. `--primary: 222 47% 11%;`.
+2. **Keep contrast ratios ≥ 4.5:1** for body text and interactive elements. Test both modes.
+3. **Prefer extending Tailwind's palette** (`tailwind.config.ts`) over hard-coding hex values in components — this keeps the theme consistent and dark-mode-friendly.
+4. **Apply colors through semantic tokens** (`bg-primary`, `text-muted-foreground`, `border-input`) rather than raw palette names when possible, so future theme changes propagate.
+
+The shadcn/ui components consume these semantic tokens, so changing the variables automatically restyles the entire component library.
+
+## Light/Dark Theme Switching
+
+Ditto includes:
+
+- **`useTheme` hook** (`src/hooks/useTheme.ts`) — read and set the current theme programmatically.
+- **CSS custom properties** in `src/index.css` — one set in `:root`, dark overrides in `.dark`.
+- **Automatic persistence** via the `AppContext` config (`config.theme`), saved to local storage.
+
+To add a theme toggle:
+
+```tsx
+import { useTheme } from '@/hooks/useTheme';
+import { Button } from '@/components/ui/button';
+import { Moon, Sun } from 'lucide-react';
+
+export function ThemeToggle() {
+  const { theme, setTheme } = useTheme();
+  return (
+    <Button
+      variant="ghost"
+      size="icon"
+      onClick={() => setTheme(theme === 'dark' ? 'light' : 'dark')}
+    >
+      {theme === 'dark' ? <Sun className="size-4" /> : <Moon className="size-4" />}
+    </Button>
+  );
+}
+```
+
+## Component Styling Patterns
+
+- **Class merging:** use the `cn()` utility (`@/lib/utils`) to combine conditional classes and override defaults without class-order bugs.
+- **Variants:** follow shadcn/ui's `class-variance-authority` pattern for component variants (`variant`, `size`). Copy an existing `ui/` component as a template.
+- **Responsive design:** lean on Tailwind breakpoints (`sm:`, `md:`, `lg:`) rather than JS media queries. Use `useIsMobile` only when layout must change based on JS-measured viewport.
+- **Interactive states:** always define `hover:`, `focus-visible:`, and `disabled:` states for clickable elements. Focus rings should use `ring-ring` / `ring-offset-background` so they pick up theme colors.
+- **Spacing:** an 8px grid (Tailwind's default 4-based scale) keeps visual rhythm consistent. Common paddings: `p-4`, `p-6`; gaps: `gap-2`, `gap-4`.
+- **Depth:** soft shadows (`shadow-sm`, `shadow-md`), subtle gradients, and `rounded-lg` / `rounded-xl` corners match Ditto's aesthetic. Avoid heavy drop shadows.
+
+### Negative z-index gotcha
+
+When placing decorative elements behind content with `-z-10` (e.g. blurred background gradients), **add `isolate` to the parent container**. Without `isolate`, the negative z-index escapes the local stacking context and the element disappears behind the page's background color.
+
+```tsx
+<section className="relative isolate">
+  <div className="absolute inset-0 -z-10 bg-gradient-to-br from-primary/20 to-transparent" />
+  {/* content */}
+</section>
+```
+
+## Design Quality Checklist
+
+Before finishing a visual change, verify:
+
+- [ ] Both light and dark modes look correct — no hard-coded colors, all text readable.
+- [ ] Contrast ratios meet WCAG AA (≥ 4.5:1 for body, ≥ 3:1 for large text).
+- [ ] Interactive elements have visible `hover`, `focus-visible`, and `disabled` states.
+- [ ] Layout is responsive down to ~360px width without horizontal scroll.
+- [ ] Animations respect `prefers-reduced-motion` (Tailwind: `motion-safe:` / `motion-reduce:`).
+- [ ] Spacing is consistent — no one-off `p-[13px]` style values.

.env.example

@@ -3,5 +3,9 @@ VITE_PLAUSIBLE_DOMAIN="example.tld"
 VITE_PLAUSIBLE_ENDPOINT="https://plausible.example.tld/api/event"
 # Hex pubkey of the nostr-push server (found in nostr-push startup logs as "worker_pubkey")
 VITE_NOSTR_PUSH_PUBKEY=""
+# Canonical origin used when generating shareable URLs (QR codes, copy-link, remote-login callbacks).
+# Primarily useful for native (Capacitor) builds, where window.location.origin is capacitor://localhost.
+# Example: VITE_SHARE_ORIGIN="https://ditto.pub"
+VITE_SHARE_ORIGIN=""
 # Set to "*" to allow any host in the Vite dev server (eg. when proxying through a custom domain)
 # ALLOWED_HOSTS="*"

.gitignore

@@ -11,6 +11,8 @@ node_modules
 dist
 dist-ssr
 *.local
+.eslintcache
+.tsbuildinfo
 yarn.lock
 deploy.sh
 

.gitlab-ci.yml

@@ -26,13 +26,17 @@ test:
   script:
     - npm run test
 
+# Disabled: nsite deploy not needed right now; re-enable by restoring the
+# rules below to run on default branch (and ensure NSITE_NBUNKSEC is set).
 deploy-nsite:
   stage: deploy
   timeout: 10 minutes
   rules:
-    - if: $CI_COMMIT_TAG
-      when: never
-    - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH
+    - when: never
+  # rules:
+  #   - if: $CI_COMMIT_TAG
+  #     when: never
+  #   - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH
   variables:
     NSYTE_VERSION: "v0.24.1"
   script:
@@ -50,7 +54,7 @@ deploy-nsite:
       nsyte deploy ./dist
       -i
       --sec "$NSITE_NBUNKSEC"
-      --name ditto
+      --name agora
       --relays "wss://relay.ditto.pub,wss://relay.nsite.lol,wss://relay.dreamith.to,wss://relay.primal.net"
       --servers "https://blossom.primal.net,https://blossom.ditto.pub,https://blossom.dreamith.to"
       --fallback "/index.html"
@@ -73,6 +77,39 @@ build-web:
     paths:
       - dist/
 
+release-notes:
+  stage: build
+  timeout: 2 minutes
+  needs: []
+  rules:
+    - if: $CI_COMMIT_TAG =~ /^v\d+\.\d+\.\d+$/
+  script:
+    # Extract release notes from CHANGELOG.md for this tag.
+    # release-notes.md is the full section (summary + bulleted lists), used as
+    # the GitLab Release description. release-notes-summary.txt is the leading
+    # plaintext paragraph only, used as the App Store / Play Store release
+    # blurb. Falls back to "Ditto vX.Y.Z" when the section has no summary.
+    - mkdir -p artifacts
+    - node scripts/extract-release-notes.mjs "$CI_COMMIT_TAG" > artifacts/release-notes.md
+    - node scripts/extract-release-notes.mjs "$CI_COMMIT_TAG" --summary > artifacts/release-notes-summary.txt
+    - echo "--- release-notes.md ---"
+    - cat artifacts/release-notes.md
+    - echo "--- release-notes-summary.txt (length $(wc -c < artifacts/release-notes-summary.txt)) ---"
+    - cat artifacts/release-notes-summary.txt
+    - echo "------------------------"
+    # Warn (don't fail) when the summary exceeds the documented 500-character
+    # limit so the user spots it before App Store / Play Store reject the upload.
+    - |
+      SUMMARY_LEN=$(wc -c < artifacts/release-notes-summary.txt)
+      if [ "$SUMMARY_LEN" -gt 501 ]; then
+        echo "WARNING: release-notes-summary.txt is $SUMMARY_LEN bytes; convention is <=500."
+      fi
+  artifacts:
+    paths:
+      - artifacts/release-notes.md
+      - artifacts/release-notes-summary.txt
+    expire_in: 90 days
+
 build-apk:
   stage: build
   image: eclipse-temurin:21-jdk
@@ -154,24 +191,24 @@ build-apk:
 
     # Copy APK to a predictable artifact path
     - mkdir -p artifacts
-    - cp android/app/build/outputs/apk/release/app-release.apk "artifacts/Ditto.apk"
-    - cp android/app/build/outputs/bundle/release/app-release.aab "artifacts/Ditto.aab"
+    - cp android/app/build/outputs/apk/release/app-release.apk "artifacts/Agora.apk"
+    - cp android/app/build/outputs/bundle/release/app-release.aab "artifacts/Agora.aab"
     - ls -lh artifacts/
 
     # Upload to Generic Packages registry for a stable public download URL
     - |
       curl --fail --header "JOB-TOKEN: ${CI_JOB_TOKEN}" \
-        --upload-file "artifacts/Ditto.apk" \
-        "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/ditto/${CI_COMMIT_TAG}/Ditto-${CI_COMMIT_TAG}.apk"
+        --upload-file "artifacts/Agora.apk" \
+        "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/agora/${CI_COMMIT_TAG}/Agora-${CI_COMMIT_TAG}.apk"
     - |
       curl --fail --header "JOB-TOKEN: ${CI_JOB_TOKEN}" \
-        --upload-file "artifacts/Ditto.aab" \
-        "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/ditto/${CI_COMMIT_TAG}/Ditto-${CI_COMMIT_TAG}.aab"
+        --upload-file "artifacts/Agora.aab" \
+        "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/agora/${CI_COMMIT_TAG}/Agora-${CI_COMMIT_TAG}.aab"
 
   artifacts:
     paths:
-      - artifacts/Ditto.apk
-      - artifacts/Ditto.aab
+      - artifacts/Agora.apk
+      - artifacts/Agora.aab
     expire_in: 90 days
   cache:
     key: android-gradle
@@ -179,35 +216,109 @@ build-apk:
       - android/.gradle/
       - .gradle/
 
+build-ipa:
+  stage: build
+  tags:
+    - macos
+  timeout: 20 minutes
+  needs: []
+  rules:
+    - if: $CI_COMMIT_TAG =~ /^v\d+\.\d+\.\d+$/
+  variables:
+    LANG: en_US.UTF-8
+    LC_ALL: en_US.UTF-8
+    FASTLANE_HIDE_CHANGELOG: "1"
+    FASTLANE_SKIP_UPDATE_CHECK: "1"
+  before_script:
+    # PATH is set up via ~/.bash_profile on the runner host (brew + Ruby 3.3 + user gems)
+    - node --version
+    - ruby --version
+    - fastlane --version | head -3
+
+    # Decode the App Store Connect API key (.p8) into a private location.
+    # The Fastfile reads this directly via File.binread. We pass the API
+    # key into match so it contacts Apple's portal to verify the cert is
+    # still valid for the team — fails fast on a revoked / expired cert.
+    - mkdir -p "$HOME/.private_keys"
+    - chmod 700 "$HOME/.private_keys"
+    - export ASC_KEY_PATH="$HOME/.private_keys/AuthKey_${APP_STORE_CONNECT_API_KEY_ID}.p8"
+    - echo "$APP_STORE_CONNECT_API_KEY_P8_BASE64" | base64 -d > "$ASC_KEY_PATH"
+    - chmod 600 "$ASC_KEY_PATH"
+    # Avoid env-var collision: match's APP_STORE_CONNECT_API_KEY_PATH expects
+    # a JSON descriptor; we pass the API key inline via the Fastfile.
+    - unset APP_STORE_CONNECT_API_KEY_PATH || true
+
+    # Build web assets and sync to Capacitor iOS project
+    - npm ci
+    - npx vite build -l error
+    - cp dist/index.html dist/404.html
+    - npx cap sync ios
+    - node scripts/patch-cap-config.mjs
+  script:
+    # Stamp marketing version from the git tag (e.g. v2.1.0 -> 2.1.0)
+    - VERSION="${CI_COMMIT_TAG#v}"
+    - echo "Building iOS version $VERSION (build ${CI_PIPELINE_IID}) from tag $CI_COMMIT_TAG"
+    - >-
+      /usr/bin/sed -i ''
+      "s/MARKETING_VERSION = [0-9.]*;/MARKETING_VERSION = ${VERSION};/g"
+      ios/App/App.xcodeproj/project.pbxproj
+
+    # Run match (cert verify + decrypt) and build_app to produce the IPA.
+    # build_app writes ./artifacts/Ditto.ipa relative to the project root.
+    - cd ios
+    - fastlane build_ipa
+    - cd ..
+
+    # Move the IPA to a stable name in the artifact directory.
+    - ls -lh artifacts/
+    - test -f artifacts/Ditto.ipa
+
+    # Upload to the Generic Packages registry for a stable public download URL,
+    # mirroring how build-apk publishes the APK and AAB.
+    - |
+      curl --fail --header "JOB-TOKEN: ${CI_JOB_TOKEN}" \
+        --upload-file "artifacts/Ditto.ipa" \
+        "${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/ditto/${CI_COMMIT_TAG}/Ditto-${CI_COMMIT_TAG}.ipa"
+  after_script:
+    # Wipe the API key so nothing sensitive sticks around between jobs.
+    - rm -f "$HOME/.private_keys"/AuthKey_*.p8 || true
+  artifacts:
+    paths:
+      - artifacts/Ditto.ipa
+    expire_in: 90 days
+
 release:
   stage: release
   image: registry.gitlab.com/gitlab-org/release-cli:latest
   needs:
-    - build-apk
+    - job: build-apk
+      artifacts: false
+    - job: build-ipa
+      artifacts: false
+    - job: release-notes
+      artifacts: true
   rules:
     - if: $CI_COMMIT_TAG =~ /^v\d+\.\d+\.\d+$/
   script:
     - echo "Creating release for $CI_COMMIT_TAG"
-    # Extract the latest changelog section for the release description.
-    # Reads from "## [version]" to the next "## [" or end of file.
-    - |
-      VERSION="${CI_COMMIT_TAG#v}"
-      RELEASE_NOTES=$(awk "/^## \\[${VERSION}\\]/{found=1; next} /^## \\[/{if(found) exit} found{print}" CHANGELOG.md)
-      if [ -z "$RELEASE_NOTES" ]; then
-        RELEASE_NOTES="Ditto ${CI_COMMIT_TAG}"
-      fi
-    - echo "$RELEASE_NOTES" > release-notes.md
+    - test -f artifacts/release-notes.md
+    - echo "--- release-notes.md ---"
+    - cat artifacts/release-notes.md
+    - echo "------------------------"
   release:
     tag_name: $CI_COMMIT_TAG
     name: $CI_COMMIT_TAG
-    description: './release-notes.md'
+    description: './artifacts/release-notes.md'
     assets:
       links:
-        - name: Ditto-${CI_COMMIT_TAG}.apk
-          url: ${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/ditto/${CI_COMMIT_TAG}/Ditto-${CI_COMMIT_TAG}.apk
+        - name: Agora-${CI_COMMIT_TAG}.apk
+          url: ${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/agora/${CI_COMMIT_TAG}/Agora-${CI_COMMIT_TAG}.apk
           link_type: package
-        - name: Ditto-${CI_COMMIT_TAG}.aab
-          url: ${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/ditto/${CI_COMMIT_TAG}/Ditto-${CI_COMMIT_TAG}.aab
+        - name: Agora-${CI_COMMIT_TAG}.aab
+          url: ${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/agora/${CI_COMMIT_TAG}/Agora-${CI_COMMIT_TAG}.aab
+          link_type: package
+        - name: Ditto-${CI_COMMIT_TAG}.ipa
+          url: ${CI_API_V4_URL}/projects/${CI_PROJECT_ID}/packages/generic/ditto/${CI_COMMIT_TAG}/Ditto-${CI_COMMIT_TAG}.ipa
           link_type: package
 
 publish-zapstore:
@@ -230,7 +341,7 @@ publish-zapstore:
     - mkdir -p ~/.config/zsp/bunker-keys
     - echo "$ZAPSTORE_CLIENT_KEY" > ~/.config/zsp/bunker-keys/${BUNKER_PUBKEY}.key
 
-    - APK_PATH="artifacts/Ditto.apk"
+    - APK_PATH="artifacts/Agora.apk"
     - VERSION="${CI_COMMIT_TAG#v}"
     - sed -i "2i release_source:\ ./${APK_PATH}" zapstore.yaml
     - sed -i "2i version:\ ${VERSION}" zapstore.yaml
@@ -240,7 +351,10 @@ publish-google-play:
   stage: publish
   image: ruby:3.3
   needs:
-    - build-apk
+    - job: build-apk
+      artifacts: true
+    - job: release-notes
+      artifacts: true
   rules:
     - if: $CI_COMMIT_TAG =~ /^v\d+\.\d+\.\d+$/
   script:
@@ -249,18 +363,87 @@ publish-google-play:
     # Decode base64-encoded service account JSON to a temp file
     - echo "$GOOGLE_PLAY_SERVICE_ACCOUNT_JSON" | base64 -d > /tmp/play-service-account.json
 
-    # Upload the AAB to Google Play production track
+    # Build the fastlane supply metadata layout for the changelog.
+    # supply maps changelogs/<versionCode>.txt to the Play Console "What's
+    # new in this version" field. versionCode matches what build-apk stamped
+    # into build.gradle (= CI_PIPELINE_IID).
+    - VERSION_CODE="${CI_PIPELINE_IID}"
+    - CHANGELOG_DIR="android/fastlane/metadata/android/en-US/changelogs"
+    - mkdir -p "$CHANGELOG_DIR"
+    - cp artifacts/release-notes-summary.txt "${CHANGELOG_DIR}/${VERSION_CODE}.txt"
+    - echo "--- ${CHANGELOG_DIR}/${VERSION_CODE}.txt ---"
+    - cat "${CHANGELOG_DIR}/${VERSION_CODE}.txt"
+    - echo "-------------------------------------------"
+
+    # Upload the AAB to Google Play production track with the changelog.
     - >-
       fastlane supply
-      --aab artifacts/Ditto.aab
-      --package_name pub.ditto.app
+      --aab artifacts/Agora.aab
+      --package_name pub.agora.app
       --track production
       --json_key /tmp/play-service-account.json
+      --metadata_path android/fastlane/metadata/android
       --skip_upload_metadata
-      --skip_upload_changelogs
       --skip_upload_images
       --skip_upload_screenshots
       --skip_upload_apk
 
     # Clean up
     - rm -f /tmp/play-service-account.json
+
+publish-app-store:
+  stage: publish
+  # Runs on the self-hosted Mac runner, same as build-ipa. fastlane's `deliver`
+  # action shells out to Apple's iTMSTransporter / altool to upload the IPA
+  # binary, and those tools ship inside Xcode. On a generic Linux container
+  # the upload step crashes with `No such file or directory @ dir_chdir0`
+  # because `Helper.itms_path` resolves to a path inside Xcode that doesn't
+  # exist. The IPA is already signed in `build-ipa`; we just need an Apple
+  # tool to push it, which means macOS.
+  tags:
+    - macos
+  needs:
+    - job: build-ipa
+      artifacts: true
+    - job: release-notes
+      artifacts: true
+  rules:
+    - if: $CI_COMMIT_TAG =~ /^v\d+\.\d+\.\d+$/
+  variables:
+    LANG: en_US.UTF-8
+    LC_ALL: en_US.UTF-8
+    FASTLANE_HIDE_CHANGELOG: "1"
+    FASTLANE_SKIP_UPDATE_CHECK: "1"
+  before_script:
+    # PATH is set up via ~/.bash_profile on the runner host (brew + Ruby 3.3 + user gems)
+    - ruby --version
+    - fastlane --version | head -3
+
+    # Decode the App Store Connect API key (.p8) into a private location.
+    # The Fastfile reads this directly via File.binread.
+    - mkdir -p "$HOME/.private_keys"
+    - chmod 700 "$HOME/.private_keys"
+    - export ASC_KEY_PATH="$HOME/.private_keys/AuthKey_${APP_STORE_CONNECT_API_KEY_ID}.p8"
+    - echo "$APP_STORE_CONNECT_API_KEY_P8_BASE64" | base64 -d > "$ASC_KEY_PATH"
+    - chmod 600 "$ASC_KEY_PATH"
+    # Avoid env-var collision: match's APP_STORE_CONNECT_API_KEY_PATH expects
+    # a JSON descriptor; we pass the API key inline via the Fastfile.
+    - unset APP_STORE_CONNECT_API_KEY_PATH || true
+  script:
+    - test -f artifacts/Ditto.ipa
+    - test -f artifacts/release-notes-summary.txt
+
+    # Use the release summary paragraph as the App Store "What's New" text.
+    # Generated by the release-notes job from CHANGELOG.md.
+    - mkdir -p ios/fastlane/metadata/en-US
+    - cp artifacts/release-notes-summary.txt ios/fastlane/metadata/en-US/release_notes.txt
+    - echo "--- release_notes.txt ---"
+    - cat ios/fastlane/metadata/en-US/release_notes.txt
+    - echo "-------------------------"
+
+    # Submit the prebuilt IPA from build-ipa to App Store Connect for review.
+    - export IPA_PATH="$CI_PROJECT_DIR/artifacts/Ditto.ipa"
+    - cd ios
+    - fastlane submit_release
+  after_script:
+    - rm -f "$HOME/.private_keys"/AuthKey_*.p8 || true

.gitlab/merge_request_templates/Default.md

@@ -1,4 +1,4 @@
-Thanks for contributing to Ditto! Please read [CONTRIBUTING.md](CONTRIBUTING.md) in full before submitting -- it covers everything you need to get your MR accepted.
+Thanks for contributing to Agora! Please read [CONTRIBUTING.md](CONTRIBUTING.md) in full before submitting -- it covers everything you need to get your MR accepted.
 
 ## Related Issue
 
@@ -29,9 +29,9 @@ Closes #
 ## Philosophy Alignment
 
 <!-- Answer this question for your change: -->
-<!-- "Does this make Ditto more magnetic, more threatening to the status quo, -->
+<!-- "Does this make Agora more magnetic, more threatening to the status quo, -->
 <!-- and more peaceful to inhabit?" -->
-<!-- See: https://about.ditto.pub/philosophy -->
+<!-- See: CONTRIBUTING.md -> "Understanding Agora" -->
 <!-- For bug fixes: "Bug fix -- restores intended behavior" is acceptable. -->
 
 ## How to Test
@@ -50,7 +50,7 @@ Closes #
 ### Process
 
 - [ ] I read `AGENTS.md` before starting
-- [ ] I read the [Ditto Philosophy](https://about.ditto.pub/philosophy)
+- [ ] I read "Understanding Agora" in `CONTRIBUTING.md`
 - [ ] I used plan/research mode before writing code
 - [ ] I used Claude Opus 4.6 (or equivalent frontier model)
 

.npmrc

@@ -0,0 +1 @@
+legacy-peer-deps=true

.vscode/settings.json

@@ -1,3 +1,4 @@
 {
-  "editor.tabSize": 2
+  "editor.tabSize": 2,
+  "typescript.tsdk": "node_modules/typescript/lib"
 }

CHANGELOG.md

@@ -1,417 +1,7 @@
 # Changelog
 
-## [2.7.0] - 2026-04-14
+## [1.0.0] - 2026-04-30
 
 ### Added
-- Customizable widget sidebar -- drag, drop, and rearrange widgets on your feed including Trending, Hot Posts, Bluesky, AI Chat, Blobbi, Music, Photos, Wikipedia, and more
-- Blobbi rooms -- swipe between living spaces, clean up after your pet, and earn XP from daily care routines
-- Native push notifications on iOS with author names, content previews, and smart grouping by category
-- Haptic feedback throughout the app -- taps, buzzes, and pulses when you react, zap, repost, pull to refresh, play games, and interact with your Blobbi
-- Hot Posts widget showing the most popular posts from your feed at a glance
 
-### Changed
-- Sidebar widgets are now clickable links that take you to their full pages
-- Blobbi widget shows live stats with circular ring indicators and quick action buttons
-
-### Fixed
-- Zaps embedded in posts now render as proper inline cards instead of blank space
-- Quote posts display media and Blobbi companions correctly
-- Deep linking on Google Play works again
-- Game controller buttons no longer trigger text selection on long-press on iOS
-
-## [2.6.6] - 2026-04-12
-
-### Fixed
-- Emoji and mention autocomplete dropdowns no longer get clipped by the compose box
-- Emoji shortcodes now render as color emoji instead of plain text glyphs
-- Dialogs and input fields on Android are no longer obscured by the virtual keyboard
-- Signing requests on Android are more reliable and no longer silently fail after switching apps
-
-## [2.6.5] - 2026-04-11
-
-### Changed
-- Apps and games load significantly faster on Android with smarter prefetching and server affinity
-- Native loading spinners replace HTML-based ones on iOS and Android for a smoother experience
-
-### Fixed
-- External API requests on Android no longer fail due to hostname restrictions
-- iOS App Store compliance issues resolved
-
-## [2.6.4] - 2026-04-11
-
-### Added
-- iCloud Keychain integration on iOS -- your login credentials are now saved and restored automatically across devices
-
-### Changed
-- Empty feeds show a friendlier state with a discover button to help you find people to follow
-- Signup flow simplified -- cleaner profile step with a single Continue button
-
-### Fixed
-- Avatar fallback now shows the user's initial instead of a question mark
-- Android 16+ devices no longer have content hidden behind system bars
-- Signup dialog background clears properly when switching between light and dark themes
-- Sticky compose button stays anchored to the bottom even on empty feeds
-
-## [2.6.3] - 2026-04-10
-
-### Added
-- Lightning invoices embedded in posts now render as tappable payment cards
-- Blobbi companions in the feed reflect their current condition and projected health
-
-### Changed
-- Profile headers are cleaner -- lightning addresses and verification badges moved out of the way, and website URLs no longer show a trailing slash
-- Login credentials are saved to your browser's built-in password manager for easier sign-in across sessions
-- "Request to Vanish" renamed to "Delete Account" for clarity
-
-### Fixed
-- Badge image uploads now show a recommended 1:1 aspect ratio hint so your badges don't get cropped unexpectedly
-- Security hardening for URLs and styles sourced from the network
-
-## [2.6.2] - 2026-04-08
-
-### Added
-- Share follow packs and follow sets via link -- recipients see an immersive preview with member avatars, a "Follow All" button, and a combined feed from everyone in the pack
-- Curated home feed with a mix of photos, short videos, livestreams, and music -- content types are spaced out so your timeline stays fresh and varied
-- "Write a letter" option on profile menus for a more personal way to reach out
-- Push vs persistent notification delivery option on Android
-
-### Changed
-- Webxdc games and apps always open fullscreen for a more immersive experience
-- Login credentials are now stored in the device's secure keychain on iOS and Android instead of plain local storage
-- Profile fields now appear inline instead of in a separate right sidebar
-- Trending hashtags removed from the logged-out homepage for a cleaner first impression
-
-### Fixed
-- Webxdc and nsites work natively on iOS and Android without relying on browser sandboxing tricks
-- File downloads now save directly to Documents on iOS and Android instead of silently failing
-- Mobile search no longer scrolls the page behind it and properly hides the bottom navigation bar
-- iOS swipe-back navigation works correctly throughout the app
-- Blobbi companions appear reliably on profiles instead of sometimes going missing
-- IndexedDB no longer crashes on devices with Lockdown Mode enabled
-
-## [2.6.1] - 2026-04-06
-
-### Added
-- Manage your interest tabs (hashtags and locations) from the settings page
-- Edit button on custom profile tabs so you can tweak them without recreating from scratch
-- Follow packs and follow sets now show author info and action headers in the feed
-- Posts now show whether they were created or updated, so you can tell when something's been edited
-
-### Changed
-- Webxdc games and apps run in a more secure sandbox with stricter content policies and private subdomains
-- Nsite previews now use the same secure sandbox as webxdc apps
-- Blobbi items work as instant abilities instead of consumable inventory -- no more fiddly quantity pickers
-
-### Fixed
-- Desktop tab bar no longer overflows when you have lots of tabs -- scroll arrows appear automatically
-- Mobile compose box no longer randomly collapses or becomes unclickable
-- Profile avatar and banner lightbox no longer hides behind the right sidebar
-- Infinite scroll on custom profile tab feeds no longer reloads the same content
-- Reaction emoji are now visible on each row in the interactions modal
-- Missing bottom border on collapsed thread expand button restored
-
-## [2.6.0] - 2026-04-05
-
-### Added
-- Follow links and QR codes -- share a link or scannable code that lets anyone follow you with one tap, complete with your themed profile preview and recent posts
-- Immersive Blobbi hatching ceremony -- crack your egg through cinematic stages with shaking animations, a burst of light, sparkles, typewriter dialog, and a naming moment
-
-### Changed
-- Footer links redesigned as compact icon chips for a cleaner look
-- Custom emoji now render crisp at small sizes with pixel-perfect scaling
-
-### Fixed
-- Custom themes now apply correctly when logging in on a new device
-- Settings and preferences sync reliably across devices
-- Mobile sidebar links no longer clip into the safe area
-- Blobbi page background overlay now appears properly on custom themes
-- Blobbi companion state no longer resets unexpectedly from stale cache data
-- Letter compose picker no longer gets hidden behind the top navigation arc
-
-## [2.5.2] - 2026-04-04
-
-### Added
-- See who voted on each poll option -- tap the vote count to open a voters list with avatar stacks and per-option filter tabs
-- Poll votes now appear as activity cards in feeds and on detail pages
-
-### Fixed
-- Threads and replies load more reliably by following relay and author hints when fetching parent events
-
-## [2.5.1] - 2026-04-03
-
-### Fixed
-- Lightbox now reliably appears above all content, not just when opened from photo galleries
-
-## [2.5.0] - 2026-04-03
-
-### Added
-- Run nsites and web apps directly inside Ditto -- hit the "Run" button on any nsite or app card to preview it in an overlay without leaving your feed
-- File uploads in the poll composer -- attach images and media to your polls
-- Blobbi posts now appear in the homepage feed
-
-### Changed
-- Profile media sidebar fills remaining slots with photos from text posts when there aren't enough dedicated media posts
-- App cards now show banner images and improved layout
-
-### Fixed
-- Lightbox no longer appears behind the right sidebar
-- Compose box corners are properly rounded
-- Clicking buttons or links inside a post card no longer accidentally navigates to the post detail page
-
-## [2.4.1] - 2026-04-02
-
-### Added
-- Rich cards for Zapstore app releases and assets -- see download links, version info, platform badges, and hashes right in your feed
-
-### Fixed
-- First-hatch tour now shows for accounts that were onboarded before the tour existed, so no one misses the hatching moment
-
-## [2.4.0] - 2026-04-02
-
-### Added
-- First-hatch tour: a guided experience for hatching your very first Blobbi egg, with progressive crack animations, an inline card flow, and a reveal moment
-- Customizable bottom bar: rearrange or hide any item in the navigation bar to make Ditto feel like yours
-- Mission surface card in the feed that surfaces your active quests at a glance
-
-### Changed
-- Missions redesigned as a quest board with collapsible cards and a lighter aesthetic
-- "Edit Profile" mission now completes when you update any profile field, not just wall-specific edits
-- Media tab on profiles now shows only photos, videos, and other media -- not plain text posts
-- Blobbi onboarding state now syncs to your profile so it follows you across devices
-
-### Fixed
-- Notification dot no longer reappears after you've already marked notifications as read
-- Dialogs no longer fly up when the mobile keyboard opens
-
-## [2.3.1] - 2026-04-02
-
-### Changed
-- Drafts now save instantly to your device and sync to relays in the background, with a cloud sync indicator so you always know the status
-
-### Fixed
-- Dialogs stay visible above the keyboard on mobile instead of getting hidden behind it
-- Editing an existing article no longer incorrectly warns about a duplicate slug
-- Switching between rich text and markdown source mode no longer clears your content
-- Fix crash when editing in markdown source mode
-
-## [2.3.0] - 2026-04-02
-
-### Added
-- In-app article editor with a rich text toolbar, image uploads, auto-saving drafts, and a "My Articles" tab to manage drafts and published articles
-
-### Fixed
-- Custom emoji no longer stretch to fill their container
-- Mobile drawer now closes when tapping footer links like Changelog or Privacy
-- Logged-out users now default to the global tab on content feeds instead of seeing an empty follows tab
-
-## [2.2.11] - 2026-04-02
-
-### Fixed
-- Fix crash caused by the "What's new" toast firing outside the router
-
-## [2.2.10] - 2026-04-02
-
-### Added
-- App cards for Nostr apps now display in feeds and detail pages with hero images, icons, and quick-launch buttons
-- "What's new" toast appears after an app update with a changelog preview and link to the full changelog
-
-### Changed
-- Changelog page redesigned with a hero section for the latest release, collapsible older entries, and category icons inline with each item
-
-### Fixed
-- Compose box now fully resets to its collapsed state after posting, including poll options and media trays
-
-## [2.2.9] - 2026-04-01
-
-### Added
-- Emoji pack creator and editor with drag-and-drop image upload, auto-generated identifiers, and description field
-- Blobbi companions now appear in feeds and post detail pages
-
-### Changed
-- Blobbi shop redesigned with a tile layout and instant buy -- no more categories or accessory tabs
-- Emoji packs without any valid emojis are now hidden from feeds
-- Custom emoji shortcode collisions across packs are automatically resolved with pack-prefixed names
-
-## [2.2.8] - 2026-04-01
-
-### Added
-- Full threaded reply trees on post detail pages with collapsible deep branches and "Show X more replies" for sibling threads
-- Broadcast button in the Event JSON dialog to re-publish any event to your relays
-
-### Changed
-- My Badges tab overhauled with drag-and-drop reordering, a scrollable list, and a showcase-style carousel for pending badges
-- Encrypted letter envelopes now show the mailing side first (sender and recipient), then flip to reveal the wax seal
-- Blobbi companions are more expressive -- richer status reactions, sleeping visuals, and body effects like dirt and hunger cues
-
-### Fixed
-- Notification dot not clearing after marking notifications as read
-- Followers/following modal staying open after navigating to a profile
-
-## [2.2.7] - 2026-03-31
-
-### Fixed
-- Nushu script in encrypted letters now renders correctly on Android and iOS
-
-## [2.2.6] - 2026-03-31
-
-### Added
-- Encrypted letters now appear as interactive 3D envelopes with Nushu script -- flip and open them to reveal the secret writing inside
-- Zap receipts and profile metadata events now render in feeds and detail pages
-- Remote signer callback page for login flows with Amber, Primal, and other signing apps
-
-### Changed
-- Post action buttons extracted into a reusable PostActionBar component
-- Badge detail page streamlined with unified tab bar
-
-### Fixed
-- Hashtags now support accented and Unicode characters
-- Letter compose opens correctly from notifications and the letters page
-- Letter font picker loads fonts so each option previews in the correct typeface
-- Zap comment positioned inside the right column instead of floating with offset
-- Safe-area padding on pinned SubHeaderBar only applies when scrolled to top
-
-## [2.2.5] - 2026-03-30
-
-### Fixed
-- Crash when dragging profile tabs to reorder them
-
-## [2.2.4] - 2026-03-30
-
-### Changed
-- Profiles now have an emoji reaction button instead of a zap button -- express yourself with any emoji or custom emoji right on someone's profile
-- Zap moved to the profile overflow menu so it's still one tap away
-
-### Fixed
-- Crash on the notifications page caused by malformed badge award tags
-- Deleting a badge now also deletes all awards you issued for it
-- Custom emoji reactions missing their image tag no longer render as broken shortcodes
-- Deletion requests for addressable events now include both `e` and `a` tags for broader relay compatibility
-- Profile reactions no longer collapse into a single grouped notification
-- Oversized reaction emoji in comment context headers
-
-## [2.2.3] - 2026-03-30
-
-### Added
-- Letters now have an overflow menu, reply button, and a grid layout for browsing
-- Independent feed toggles for comments and generic reposts in content settings
-- Sidebar items are now visible to logged-out users so newcomers can explore everything
-
-### Changed
-- Compose textarea expands smoothly as you type instead of snapping to a new height
-- Blobbi stickers auto-shrink near card edges and clip cleanly at rounded boundaries
-
-### Fixed
-- Feed gaps when replies are disabled no longer cause missing posts
-- Avatar shape no longer flashes on load
-- Top bar arc no longer flickers during navigation transitions
-- Letter drawing-only sends, sticker drag bounds, and theme event preservation
-- Notification rendering for badges and letters
-- Duplicate React keys in content settings
-- Layout rendering warning when switching views
-
-## [2.2.2] - 2026-03-29
-
-### Added
-- Dedicated photo upload flow for sharing photos
-- Pull-to-refresh on all feed pages
-- 3D tilt effect on badge images -- hover over badges to see them pop
-- Multi-select badge awarding with indicators for already-sent badges
-- Badge list recovery dialog for restoring profile badge lists
-- Compact badge row preview in embedded profile badges events
-- Custom emoji usage tracking so your most-used custom emojis appear in the quick-react bar
-- Release notes now included in Zapstore publishing
-- Changelog link in the app footer
-
-### Changed
-- "Vines" renamed to "Divines" everywhere in the app
-- Custom emojis appear first in the emoji picker, right after recent
-- Threaded comment view now shows the parent event as a NoteCard with kind action headers
-
-### Fixed
-- Delete post dialog no longer freezes the feed on desktop
-- Amber login on Android now properly retries when returning from the background
-- Key downloads on Android save to the correct location
-- Custom emoji SVGs render correctly in the emoji-mart picker
-- Double-tap reactions now properly show the emoji on the post
-- Emoji shortcode autocomplete text and highlight colors
-- Profile skeleton no longer flickers for brand-new users with no metadata
-- Event links now route correctly for all event types
-- Badge notifications are now clickable
-- Custom profile tab form no longer retains fields from a previously edited tab
-- Double line under profile tabs in edit mode
-- Inconsistent use of "geocache" vs "treasures" terminology
-- Search page "N new posts" pill no longer shows unfiltered count
-- Stale-cache overwrites in replaceable event mutations
-- Click-through on delete confirmation and note menu items
-
-## [2.2.1] - 2026-03-28
-
-### Fixed
-- New posts no longer cause scroll jumps -- they buffer while you're reading and appear with a tap
-- Mobile header no longer shows double-layered backgrounds on notched devices
-- Pinned tabs stay properly positioned when scrolling on mobile
-- Signer approval toasts no longer fire in rapid succession on unstable connections
-- Toasts are easier to swipe away on mobile
-- Content warnings now blur thumbnails in the media grid
-
-## [2.2.0] - 2026-03-28
-
-### Added
-- Blobbi virtual pets -- adopt an egg, hatch it, evolve it into one of 16 adult forms, and care for it with feeding, cleaning, medicine, music, and singing
-- Blobbi companion that follows you around the app, tracks your cursor, blinks, expresses emotions, and reacts to what you're doing
-- Blobbi shop and inventory system with items that affect your pet's stats
-- Daily missions with reroll, care streaks, and stage-based rewards
-- Immersive full-screen divines experience on both mobile and desktop with floating controls
-- Relay information panel on the network settings page
-- Link preview cards now display inside quoted posts instead of raw URLs
-- Nsec paste guard warns you before accidentally pasting private keys outside the login field
-- Remote signer UX improvements for Amber users on Android
-- Badge awards now trigger push notifications
-- Badges display in profile bio section with a "Give badge" option in the profile menu
-
-### Changed
-- Notification "Mentions" tab now shows only pure mentions, filtering out replies
-- Notification preferences ("only from people I follow") now properly apply to push notifications, native Android notifications, and the unread dot
-- Upgraded from React 18 to React 19
-- Reduced initial bundle size by ~50% with improved code splitting and lazy loading
-
-### Fixed
-- Zapping Primal users no longer produces an error
-- Hashtag feeds now match case-insensitively for parity with search results
-- Mobile top bar arc no longer lingers on pages without tabs
-- Give Badge dialog and profile menu action handlers
-
-## [2.1.1] - 2026-03-27
-
-### Added
-- Emoji picker and shortcode autocomplete in zap comment box
-- Zap button on badge detail view
-- Theme descriptions now display on "updated their theme" posts and detail pages
-- Badge thumbnail previews in award notifications
-- Letter notifications with envelope card preview
-- Kind-specific labels in notification text instead of generic "post"
-
-### Fixed
-- Compose modal no longer closes when dismissing emoji picker on mobile
-- Compose preview overflow is now scrollable in modal
-- Toast notifications swipe up to dismiss on mobile instead of sideways
-- File downloads and URL opening work correctly on iOS
-- Badges page no longer shows infinite skeleton when logged out
-
-## [2.1.0] - 2026-03-26
-
-### Added
-- Letters -- a Wii Mail-inspired inbox for sending decorated letters to friends, complete with custom stationery, hand-drawn stickers, emoji stickers, fonts, and a send animation with envelope and wax seal
-- Attach a color moment or theme to your letter as a gift -- recipients can tap to apply it instantly
-- Stationery picker pulls from your color moments, followed users' themes, and built-in presets
-- Freehand drawing canvas for creating one-of-a-kind sticker doodles
-- Letters page added to the sidebar with a custom mailbox icon
-
-## [2.0.1] - 2026-03-26
-
-### Added
-- Tap the version number in settings to see what's new
-
-## [2.0.0] - 2026-03-26
-
-Initial release of Ditto 2.0 -- a complete rewrite of Ditto.
+- Initial Agora 3 release.

CONTRIBUTING.md

@@ -1,42 +1,42 @@
-# Contributing to Ditto
+# Contributing to Agora
 
-We welcome contributions, but we have high standards. Ditto is a carefully designed product with a specific vision, and every merge request must meet that bar. This guide exists to help you succeed.
+We welcome contributions, but we have high standards. Agora is a carefully designed product with a specific vision, and every merge request must meet that bar. This guide exists to help you succeed.
 
 **Required reading before you start:**
 
-- [Ditto Philosophy](https://about.ditto.pub/philosophy) -- the product vision. Your change must align with it.
-- [Contributing Guide](https://about.ditto.pub/contributing) -- the upstream contribution process.
+- [Understanding Agora](#understanding-agora) -- the product vision. Your change must align with it.
+- This `CONTRIBUTING.md` guide -- the contribution process for this repository.
 - `AGENTS.md` in this repo -- the codebase conventions. Your AI tool should load this file.
 
-## Understanding Ditto
+## Understanding Agora
 
-Ditto is a carnival, not a platform. Before contributing, you need to understand what that means.
+Agora is a carnival, not a platform. Before contributing, you need to understand what that means.
 
 ### The product decision filter
 
-Every change to Ditto should pass this test:
+Every change to Agora should pass this test:
 
-> *Does this make Ditto more magnetic, more threatening to the status quo, and more peaceful to inhabit?*
+> *Does this make Agora more magnetic, more threatening to the status quo, and more peaceful to inhabit?*
 
-- **Magnetic** -- Ditto attracts through experience, not ideology. People don't need to understand Nostr to love it. They need to feel something they haven't felt online since the early web. Features should be odd, intriguing, and captivating -- not generic social media clones.
-- **Threatening to the status quo** -- Ditto threatens mainstream platforms when someone opens it and thinks: *"Why can't my platform do this?"* Theming, games, treasure hunts, interoperable micro-apps -- these are things walled gardens can't replicate.
-- **Peaceful to inhabit** -- Ditto displaces argument with creation, conformity with expression, and consumption with participation. No ads, no engagement-optimized algorithms, no outrage incentives.
+- **Magnetic** -- Agora attracts through experience, not ideology. People don't need to understand Nostr to love it. They need to feel something they haven't felt online since the early web. Features should be odd, intriguing, and captivating -- not generic social media clones.
+- **Threatening to the status quo** -- Agora threatens mainstream platforms when someone opens it and thinks: *"Why can't my platform do this?"* Theming, games, treasure hunts, interoperable micro-apps -- these are things walled gardens can't replicate.
+- **Peaceful to inhabit** -- Agora displaces argument with creation, conformity with expression, and consumption with participation. No ads, no engagement-optimized algorithms, no outrage incentives.
 
 If a change does all three, it belongs. If it only does one, think harder. If it does none, it doesn't belong here.
 
-### What Ditto is NOT
+### What Agora is NOT
 
 - A Twitter/X clone with decentralization bolted on
 - A place to replicate features that mainstream platforms already do well
 - A showcase for generic UI components or boilerplate social features
 
-### What Ditto IS
+### What Agora IS
 
 - A convergence point for interoperable Nostr experiences (games, treasure hunts, magic decks, themes, color moments, live streams, and things nobody has imagined yet)
 - A place where profiles feel like worlds, not business cards
 - The most fun you've had on the internet in years
 
-Read the [full philosophy](https://about.ditto.pub/philosophy) for the complete vision.
+Read the full "Understanding Agora" section above for the complete vision.
 
 ## What we accept
 
@@ -44,17 +44,19 @@ Read the [full philosophy](https://about.ditto.pub/philosophy) for the complete
 
 One bug, one merge request. Fix exactly one thing. Don't bundle unrelated changes, don't sneak in refactors, don't "clean up while you're in there." Small, focused MRs get reviewed fast. Large ones sit.
 
+When the bug was introduced by an identifiable prior commit, add a `Regression-of: <short-sha>` trailer to the bottom of your commit message. See AGENTS.md "Attributing Regressions" for the convention.
+
 ### New features and significant changes
 
-Every feature MR must link to an existing open issue and clearly align with the [Ditto Philosophy](https://about.ditto.pub/philosophy). The philosophy alignment section in the MR template is where you make the case for why your change belongs in Ditto. If you can't articulate that clearly, the change probably doesn't belong.
+Every feature MR must link to an existing open issue and clearly align with the "Understanding Agora" section in this file. The philosophy alignment section in the MR template is where you make the case for why your change belongs in Agora. If you can't articulate that clearly, the change probably doesn't belong.
 
 If you have an idea for a feature that doesn't have an issue yet:
 
-1. Build it as a standalone Nostr app first (see [Contributing Guide](https://about.ditto.pub/contributing)).
+1. Build it as a standalone Nostr app first (then document traction/feedback in the linked issue).
 2. Prove it works and get user feedback.
 3. Open an issue to discuss integration.
 
-**Feature MRs that don't link to an issue or don't align with the Ditto Philosophy will be closed.** Our open issues are our internal roadmap -- some require deep product context. If your implementation doesn't match the product vision, it will be closed regardless of code quality.
+**Feature MRs that don't link to an issue or don't align with the Agora Philosophy will be closed.** Our open issues are our internal roadmap -- some require deep product context. If your implementation doesn't match the product vision, it will be closed regardless of code quality.
 
 ## Required tools
 
@@ -80,7 +82,7 @@ Read `AGENTS.md` in the repo root. This is the single source of truth for how co
 
 ### 4. Read the philosophy
 
-Read the [Ditto Philosophy](https://about.ditto.pub/philosophy). Ditto is a carnival, not a platform. Your change should feel like it belongs in Ditto -- not like it was transplanted from a generic social media template. Apply the product decision filter above.
+Read "Understanding Agora" in this file. Agora is a carnival, not a platform. Your change should feel like it belongs in Agora -- not like it was transplanted from a generic social media template. Apply the product decision filter above.
 
 ### 5. Plan before you code
 
@@ -131,6 +133,7 @@ maintain it long-term. For each finding, state the file, line, and issue.
 - [ ] Are there any new images >100KB or other large binary assets that should be hosted externally?
 - [ ] Is there any use of dangerouslySetInnerHTML, eval, innerHTML, or SVG string interpolation?
 - [ ] Is any data from a Nostr event (tags, content, pubkey, URLs) used in a security-sensitive context (href, src, query filter, trust decision) without validation?
+- [ ] If this is a bug fix and the offending commit is identifiable, does the commit message include a `Regression-of: <short-sha>` trailer? (See AGENTS.md "Attributing Regressions".)
 
 Skip anything a linter or type checker would catch. Focus on logic, data flow, and intent.
 
@@ -163,7 +166,7 @@ Fill out every field in the MR template. Incomplete MRs will not be reviewed.
 ## What gets your MR closed without review
 
 - No linked issue
-- Feature MRs with no clear alignment with the [Ditto Philosophy](https://about.ditto.pub/philosophy)
+- Feature MRs with no clear alignment with "Understanding Agora" in this file
 - Features that fail the product decision filter (not magnetic, not threatening to the status quo, not peaceful)
 - Incomplete MR template (missing checklist, screenshots, or preview URL)
 - Changes that go beyond what was asked for (scope creep)

Dockerfile

@@ -0,0 +1,15 @@
+FROM node:22-alpine AS builder
+WORKDIR /app
+RUN apk add --no-cache git
+COPY package*.json ./
+COPY .npmrc ./
+COPY scripts/ ./scripts/
+RUN npm ci
+COPY . .
+RUN npm run build
+
+FROM nginx:alpine
+COPY nginx.conf /etc/nginx/conf.d/default.conf
+COPY --from=builder /app/dist /usr/share/nginx/html
+EXPOSE 80
+CMD ["nginx", "-g", "daemon off;"]

README.md

@@ -1,24 +1,25 @@
-# Ditto
+# Agora
 
-Your content. Your vibe. Your rules. A fun, customizable [Nostr](https://nostr.com/) client that puts you in control.
+Power to the people.
 
-**[ditto.pub](https://ditto.pub)** | **[Docs](https://docs.ditto.pub)** | **[Source](https://gitlab.com/soapbox-pub/ditto)**
+Agora is a Nostr client focused on community ownership, expressive identity, and censorship resistance. This repository (`agora-3`) is the Agora-branded app built from the Ditto codebase.
 
-## About
+**[agora.spot](https://agora.spot)** | **[Source](https://gitlab.com/soapbox-pub/agora-3)**
 
-Ditto is an open-source, decentralized social media client built on the Nostr protocol. It's designed for people who want to have fun online without feeding the Big Tech machine. Express yourself with custom themes, Lightning payments, and an ever-growing set of content types -- all while owning your identity and data.
+## What This Repo Is
 
-Made by [Soapbox](https://soapbox.pub).
+- Agora product identity (name, theme, assets, native IDs)
+- Ditto-derived implementation with broad Nostr feature coverage
+- Configurable deployment defaults via `agora.json`
 
 ## Features
 
-- **Theming** -- 9 built-in theme presets, 19 CSS token properties for full customization, and the ability to publish and share themes as Nostr events
-- **Infinite Content Types** -- Text notes, articles, short-form videos (Divines), live streams, polls, follow packs, color moments, magic decks, geocaching, and Webxdc mini-apps
-- **Lightning Payments** -- Zap posts and profiles with sats via Nostr Wallet Connect (NWC) or WebLN
-- **Private Messaging** -- End-to-end encrypted DMs (NIP-04 and NIP-17)
-- **Comments** -- Comment on anything: posts, URLs, profiles, hashtags, books, and more (NIP-22)
-- **Self-Hosting** -- Builds to static HTML/JS/CSS. Deploy anywhere -- GitHub Pages, Netlify, Vercel, a VPS, or a Raspberry Pi
-- **Mobile** -- Android native app via Capacitor, responsive design for all screen sizes
+- **Community-first social client**: notes, articles, comments, reposts, reactions, and rich event rendering
+- **Theming system**: built-in presets + custom color/font/background themes that can be shared as events
+- **Lightning support**: zaps with Nostr Wallet Connect and WebLN
+- **Private messaging**: NIP-04 and NIP-17 direct messages
+- **Mobile app shell**: Capacitor-powered Android/iOS wrappers
+- **Self-hostable**: static web build + configurable relay and upload infrastructure
 
 ## Getting Started
 
@@ -30,13 +31,43 @@ Made by [Soapbox](https://soapbox.pub).
 ### Development
 
 ```sh
-git clone https://gitlab.com/soapbox-pub/ditto.git
-cd ditto
+git clone https://gitlab.com/soapbox-pub/agora-3.git
+cd agora-3
 npm install
 npm run dev
 ```
 
-The dev server starts at `http://localhost:8080`.
+Development server: `http://localhost:8080`
+
+### Docker Getting Started
+
+Use Docker Compose when you want the nginx reverse-proxy stack (necessary if you want decryptable media in messages - kind 15s of NIP 17):
+
+```sh
+git clone https://gitlab.com/soapbox-pub/agora-3.git
+cd agora-3
+cp .env.example .env
+docker compose up --build
+```
+
+Proxy URL: `http://localhost:8083`
+
+This starts:
+
+- `vite` service on the internal Docker network (`vite:8080`)
+- `web` service (`nginx`) on host port `8082`, proxying to Vite with websocket support
+
+Stop stack:
+
+```sh
+docker compose down
+```
+
+Production-style container build:
+
+```sh
+docker compose -f docker-compose.prod.yml up --build
+```
 
 ### Build
 
@@ -44,66 +75,58 @@ The dev server starts at `http://localhost:8080`.
 npm run build
 ```
 
-The built site is output to `dist/`.
+Build output: `dist/`
 
-### Test
-
-Runs type-checking, linting, unit tests, and a production build:
+### Validate
 
 ```sh
 npm test
 ```
 
+This runs type-checking, linting, unit tests, and production build checks.
+
 ## Configuration
 
-Ditto is configured through a `ditto.json` file at the project root, read at build time. This file is gitignored so each deployment can have its own configuration.
+Build-time config is read from `agora.json` (gitignored by default so each deployment can provide its own values).
 
 ```jsonc
 {
   "theme": "dark",
   "relayMetadata": {
     "relays": [
-      { "url": "wss://relay.ditto.pub", "read": true, "write": true }
+      { "url": "wss://relay.ditto.pub", "read": true, "write": true },
+      { "url": "wss://relay.primal.net", "read": true, "write": true },
+      { "url": "wss://relay.damus.io", "read": true, "write": true }
     ]
   },
-  "blossomServers": ["https://blossom.ditto.pub"],
-  "feedSettings": {
-    "showPosts": true,
-    "showReposts": true,
-    "showArticles": true
-    // ...and more content type toggles
-  }
+  "blossomServers": [
+    "https://blossom.ditto.pub",
+    "https://blossom.primal.net/"
+  ]
 }
 ```
 
-Configuration is resolved in three layers (highest priority first):
+Configuration priority (highest first):
 
-1. **User settings** stored in localStorage
-2. **Build config** from `ditto.json`
-3. **Hardcoded defaults**
+1. User settings (local storage)
+2. Build config (`agora.json`)
+3. Hardcoded app defaults
 
-Use an alternate config file path with: `CONFIG_FILE=./my-config.json npm run build`
+Use a custom config path:
 
-### Custom Branding
-
-For self-hosted instances:
-
-- Replace `public/logo.svg` and `public/logo.png` with your logo
-- Update the app name in `index.html` and `public/manifest.webmanifest`
-- Replace `public/og-image.jpg` for social sharing previews
-- Set default relays and upload servers in `ditto.json`
+```sh
+CONFIG_FILE=./my-config.json npm run build
+```
 
 ## Deployment
 
-Ditto builds to static files and can be deployed anywhere that serves HTML.
+Agora builds to static files and can be deployed to any static host.
 
-- **GitHub Pages / GitLab Pages** -- Push to `main` and CI auto-deploys
-- **Netlify / Vercel** -- Connect your fork and deploy. A `_redirects` file is included for SPA routing
-- **VPS / Any web server** -- Build and copy `dist/` to your server. Configure SPA routing (e.g., Nginx `try_files $uri $uri/ /index.html`)
+- GitLab/GitHub Pages
+- Netlify/Vercel
+- VPS or any web server with SPA routing fallback
 
-### Android
-
-Build a native Android app with [Capacitor](https://capacitorjs.com/):
+For Android:
 
 ```sh
 npm run build
@@ -114,40 +137,20 @@ npx cap open android
 ## Tech Stack
 
 | Layer | Technology |
-|---|---|
+| --- | --- |
 | Framework | React 18 |
 | Build | Vite |
 | Language | TypeScript |
 | Styling | TailwindCSS 3 + shadcn/ui |
-| Routing | React Router 6 |
+| Routing | React Router |
 | Data | TanStack Query |
 | Nostr | Nostrify + nostr-tools |
 | Mobile | Capacitor |
 | Testing | Vitest + React Testing Library |
 
-## Project Structure
-
-```
-src/
-  components/     UI components (100+), including shadcn/ui primitives
-  hooks/          Custom React hooks (65+)
-  pages/          Page components for each route (30+)
-  contexts/       React context providers
-  lib/            Utilities and shared logic
-  test/           Test setup and helpers
-public/           Static assets, icons, manifest
-```
-
 ## Contributing
 
-We welcome contributions but have high standards. Please read the full [Contributing Guide](CONTRIBUTING.md) before submitting a merge request. The short version:
-
-- **Bug fixes**: One bug, one MR. Keep it small and focused.
-- **New features**: Must link to an existing issue and align with the [Ditto Philosophy](https://about.ditto.pub/philosophy).
-- **Required**: Live preview URL, before/after screenshots, completed self-review checklist.
-- **Required tools**: Claude Opus 4.6 (or latest frontier model), an AI coding agent with plan mode.
-
-Read the [Ditto Philosophy](https://about.ditto.pub/philosophy) to understand what Ditto is and isn't.
+Read [CONTRIBUTING.md](CONTRIBUTING.md) before opening a merge request.
 
 ## License
 

android/app/build.gradle

@@ -7,14 +7,14 @@ if (keystorePropertiesFile.exists()) {
 }
 
 android {
-    namespace = "pub.ditto.app"
+    namespace = "pub.agora.app"
     compileSdk = rootProject.ext.compileSdkVersion
     defaultConfig {
-        applicationId "pub.ditto.app"
+        applicationId "pub.agora.app"
         minSdkVersion rootProject.ext.minSdkVersion
         targetSdkVersion rootProject.ext.targetSdkVersion
         versionCode 1
-        versionName "2.7.0"
+        versionName "2.14.4"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
         aaptOptions {
              // Files and dirs to omit from the packaged assets dir, modified to accommodate modern web apps.

android/app/src/main/AndroidManifest.xml

@@ -3,6 +3,8 @@
 
     <application
         android:allowBackup="true"
+        android:fullBackupContent="@xml/backup_rules"
+        android:dataExtractionRules="@xml/data_extraction_rules"
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:roundIcon="@mipmap/ic_launcher_round"
@@ -22,12 +24,12 @@
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
 
-            <!-- Deep links: open ditto.pub URLs in the app -->
+            <!-- Deep links: open agora.spot URLs in the app -->
             <intent-filter android:autoVerify="true">
                 <action android:name="android.intent.action.VIEW" />
                 <category android:name="android.intent.category.DEFAULT" />
                 <category android:name="android.intent.category.BROWSABLE" />
-                <data android:scheme="https" android:host="ditto.pub" />
+                <data android:scheme="https" android:host="agora.spot" />
             </intent-filter>
 
         </activity>
@@ -56,4 +58,6 @@
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
     <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
 </manifest>

android/app/src/main/java/pub/ditto/app/MainActivity.java

@@ -19,7 +19,6 @@ public class MainActivity extends BridgeActivity {
     protected void onCreate(Bundle savedInstanceState) {
         // Register native plugins before super.onCreate.
         registerPlugin(DittoNotificationPlugin.class);
-        registerPlugin(SandboxPlugin.class);
 
         super.onCreate(savedInstanceState);
 

android/app/src/main/java/pub/ditto/app/SandboxPlugin.java

@@ -1,552 +0,0 @@
-package pub.ditto.app;
-
-import android.graphics.Color;
-import android.graphics.PorterDuff;
-import android.os.Handler;
-import android.os.Looper;
-import android.util.Base64;
-import android.util.Log;
-import android.view.Gravity;
-import android.view.View;
-import android.view.ViewGroup;
-import android.webkit.JavascriptInterface;
-import android.webkit.WebResourceRequest;
-import android.webkit.WebResourceResponse;
-import android.webkit.WebSettings;
-import android.webkit.WebView;
-import android.webkit.WebViewClient;
-import android.widget.FrameLayout;
-import android.widget.ProgressBar;
-import androidx.coordinatorlayout.widget.CoordinatorLayout;
-
-import com.getcapacitor.JSObject;
-import com.getcapacitor.Plugin;
-import com.getcapacitor.PluginCall;
-import com.getcapacitor.PluginMethod;
-import com.getcapacitor.annotation.CapacitorPlugin;
-
-import org.json.JSONException;
-import org.json.JSONObject;
-
-import java.io.ByteArrayInputStream;
-import java.io.InputStream;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.TimeUnit;
-
-/**
- * Capacitor plugin that creates isolated Android WebViews for sandboxed content.
- *
- * Each sandbox uses shouldInterceptRequest to intercept all requests and forward
- * them to the JS layer as fetch events — the same protocol iframe.diy uses.
- * The React code can serve files identically regardless of platform.
- */
-@CapacitorPlugin(name = "SandboxPlugin")
-public class SandboxPlugin extends Plugin {
-
-    private static final String TAG = "SandboxPlugin";
-    private final Map<String, SandboxInstance> sandboxes = new HashMap<>();
-    private final Handler mainHandler = new Handler(Looper.getMainLooper());
-
-    @PluginMethod
-    public void create(PluginCall call) {
-        String sandboxId = call.getString("id");
-        if (sandboxId == null) {
-            call.reject("Missing required parameter: id");
-            return;
-        }
-
-        JSObject frame = call.getObject("frame");
-        if (frame == null) {
-            call.reject("Missing required parameter: frame");
-            return;
-        }
-
-        int x = frame.optInt("x", 0);
-        int y = frame.optInt("y", 0);
-        int width = frame.optInt("width", 0);
-        int height = frame.optInt("height", 0);
-
-        if (sandboxes.containsKey(sandboxId)) {
-            call.reject("Sandbox already exists: " + sandboxId);
-            return;
-        }
-
-        float density = getActivity().getResources().getDisplayMetrics().density;
-        int pxX = Math.round(x * density);
-        int pxY = Math.round(y * density);
-        int pxWidth = Math.round(width * density);
-        int pxHeight = Math.round(height * density);
-
-        mainHandler.post(() -> {
-            SandboxInstance sandbox = new SandboxInstance(sandboxId, this);
-            sandboxes.put(sandboxId, sandbox);
-
-            // Add the container (WebView + spinner overlay) on top of the
-            // Capacitor WebView. The parent is a CoordinatorLayout — using
-            // the wrong LayoutParams type causes a ClassCastException when
-            // it intercepts touch events.
-            View capWebView = getBridge().getWebView();
-            ViewGroup parent = (ViewGroup) capWebView.getParent();
-            CoordinatorLayout.LayoutParams params = new CoordinatorLayout.LayoutParams(pxWidth, pxHeight);
-            params.leftMargin = pxX;
-            params.topMargin = pxY;
-            parent.addView(sandbox.container, params);
-
-            // The spinner is now visible. Navigation is deferred until the
-            // JS layer calls navigate() — this allows the caller to
-            // pre-fetch blobs while the spinner animates.
-
-            call.resolve();
-        });
-    }
-
-    @PluginMethod
-    public void navigate(PluginCall call) {
-        String sandboxId = call.getString("id");
-        if (sandboxId == null) {
-            call.reject("Missing required parameter: id");
-            return;
-        }
-
-        mainHandler.post(() -> {
-            SandboxInstance sandbox = sandboxes.get(sandboxId);
-            if (sandbox == null) {
-                call.reject("Sandbox not found: " + sandboxId);
-                return;
-            }
-
-            sandbox.webView.loadUrl("https://" + sandboxId + ".sandbox.native/index.html");
-            call.resolve();
-        });
-    }
-
-    @PluginMethod
-    public void updateFrame(PluginCall call) {
-        String sandboxId = call.getString("id");
-        if (sandboxId == null) {
-            call.reject("Missing required parameter: id");
-            return;
-        }
-
-        JSObject frame = call.getObject("frame");
-        if (frame == null) {
-            call.reject("Missing required parameter: frame");
-            return;
-        }
-
-        int x = frame.optInt("x", 0);
-        int y = frame.optInt("y", 0);
-        int width = frame.optInt("width", 0);
-        int height = frame.optInt("height", 0);
-
-        float density = getActivity().getResources().getDisplayMetrics().density;
-        int pxX = Math.round(x * density);
-        int pxY = Math.round(y * density);
-        int pxWidth = Math.round(width * density);
-        int pxHeight = Math.round(height * density);
-
-        mainHandler.post(() -> {
-            SandboxInstance sandbox = sandboxes.get(sandboxId);
-            if (sandbox == null) {
-                call.reject("Sandbox not found: " + sandboxId);
-                return;
-            }
-
-            CoordinatorLayout.LayoutParams params = new CoordinatorLayout.LayoutParams(pxWidth, pxHeight);
-            params.leftMargin = pxX;
-            params.topMargin = pxY;
-            sandbox.container.setLayoutParams(params);
-
-            call.resolve();
-        });
-    }
-
-    @PluginMethod
-    public void respondToFetch(PluginCall call) {
-        String sandboxId = call.getString("id");
-        if (sandboxId == null) {
-            call.reject("Missing required parameter: id");
-            return;
-        }
-        String requestId = call.getString("requestId");
-        if (requestId == null) {
-            call.reject("Missing required parameter: requestId");
-            return;
-        }
-        JSObject response = call.getObject("response");
-        if (response == null) {
-            call.reject("Missing required parameter: response");
-            return;
-        }
-
-        SandboxInstance sandbox = sandboxes.get(sandboxId);
-        if (sandbox == null) {
-            call.reject("Sandbox not found: " + sandboxId);
-            return;
-        }
-
-        int status = response.optInt("status", 200);
-        String statusText = response.optString("statusText", "OK");
-        String bodyBase64 = response.optString("body", null);
-
-        Map<String, String> headers = new HashMap<>();
-        JSONObject headersObj = response.optJSONObject("headers");
-        if (headersObj != null) {
-            for (java.util.Iterator<String> it = headersObj.keys(); it.hasNext(); ) {
-                String key = it.next();
-                headers.put(key, headersObj.optString(key));
-            }
-        }
-
-        sandbox.resolveRequest(requestId, status, statusText, headers, bodyBase64);
-
-        call.resolve();
-    }
-
-    @PluginMethod
-    public void postMessage(PluginCall call) {
-        String sandboxId = call.getString("id");
-        if (sandboxId == null) {
-            call.reject("Missing required parameter: id");
-            return;
-        }
-        JSObject message = call.getObject("message");
-        if (message == null) {
-            call.reject("Missing required parameter: message");
-            return;
-        }
-
-        SandboxInstance sandbox = sandboxes.get(sandboxId);
-        if (sandbox == null) {
-            call.reject("Sandbox not found: " + sandboxId);
-            return;
-        }
-
-        mainHandler.post(() -> sandbox.postMessageToWebView(message.toString()));
-
-        call.resolve();
-    }
-
-    @PluginMethod
-    public void destroy(PluginCall call) {
-        String sandboxId = call.getString("id");
-        if (sandboxId == null) {
-            call.reject("Missing required parameter: id");
-            return;
-        }
-
-        mainHandler.post(() -> {
-            SandboxInstance sandbox = sandboxes.remove(sandboxId);
-            if (sandbox != null) {
-                ViewGroup parent = (ViewGroup) sandbox.container.getParent();
-                if (parent != null) {
-                    parent.removeView(sandbox.container);
-                }
-                sandbox.webView.destroy();
-            }
-            call.resolve();
-        });
-    }
-
-    void emitFetchRequest(String sandboxId, String requestId, JSObject request) {
-        JSObject data = new JSObject();
-        data.put("id", sandboxId);
-        data.put("requestId", requestId);
-        data.put("request", request);
-        notifyListeners("fetch", data);
-    }
-
-    void emitScriptMessage(String sandboxId, JSObject message) {
-        JSObject data = new JSObject();
-        data.put("id", sandboxId);
-        data.put("message", message);
-        notifyListeners("scriptMessage", data);
-    }
-
-    /**
-     * A single sandboxed WebView instance.
-     */
-    private static class SandboxInstance {
-        final String id;
-        /** Wrapper layout that holds the WebView and the loading overlay. */
-        final FrameLayout container;
-        final WebView webView;
-        final SandboxPlugin plugin;
-        private final ConcurrentHashMap<String, PendingRequest> pendingRequests = new ConcurrentHashMap<>();
-        /** Native spinner overlay, shown while the sandbox content loads. */
-        private ProgressBar spinner;
-
-        SandboxInstance(String id, SandboxPlugin plugin) {
-            this.id = id;
-            this.plugin = plugin;
-
-            this.container = new FrameLayout(plugin.getActivity());
-            this.webView = new WebView(plugin.getActivity());
-
-            WebSettings settings = webView.getSettings();
-            settings.setJavaScriptEnabled(true);
-            settings.setDomStorageEnabled(true);
-            settings.setAllowFileAccess(false);
-            settings.setAllowContentAccess(false);
-            settings.setDatabaseEnabled(true);
-
-            webView.setBackgroundColor(Color.parseColor("#14161f"));
-
-            // Add JavaScript interface for script->native communication.
-            webView.addJavascriptInterface(new SandboxBridge(this), "__sandboxNative");
-
-            // Inject the bridge script and intercept requests.
-            webView.setWebViewClient(new SandboxWebViewClient(this));
-
-            // Build the container: WebView fills it, spinner overlays on top.
-            container.addView(webView, new FrameLayout.LayoutParams(
-                    ViewGroup.LayoutParams.MATCH_PARENT,
-                    ViewGroup.LayoutParams.MATCH_PARENT));
-
-            // Native spinner overlay — uses the Android indeterminate
-            // ProgressBar which animates on the render thread, so it keeps
-            // spinning even when the main/IO threads are busy.
-            spinner = new ProgressBar(plugin.getActivity());
-            spinner.setIndeterminate(true);
-            spinner.getIndeterminateDrawable().setColorFilter(
-                    Color.parseColor("#7c5cdc"), PorterDuff.Mode.SRC_IN);
-            FrameLayout.LayoutParams spinnerParams = new FrameLayout.LayoutParams(
-                    dpToPx(plugin, 32), dpToPx(plugin, 32), Gravity.CENTER);
-            container.addView(spinner, spinnerParams);
-
-            // Dark background behind the spinner.
-            View overlay = new View(plugin.getActivity());
-            overlay.setBackgroundColor(Color.parseColor("#14161f"));
-            // Insert the overlay between the WebView (index 0) and spinner (index 1)
-            // so it covers the WebView but sits behind the spinner.
-            container.addView(overlay, 1, new FrameLayout.LayoutParams(
-                    ViewGroup.LayoutParams.MATCH_PARENT,
-                    ViewGroup.LayoutParams.MATCH_PARENT));
-        }
-
-        /** Remove the native loading overlay. Safe to call multiple times. */
-        void hideSpinner() {
-            if (spinner != null) {
-                // Remove spinner and overlay (indices 2 and 1 after WebView at 0).
-                if (container.getChildCount() > 2) container.removeViewAt(2); // spinner
-                if (container.getChildCount() > 1) container.removeViewAt(1); // overlay
-                spinner = null;
-            }
-        }
-
-        private static int dpToPx(SandboxPlugin plugin, int dp) {
-            float density = plugin.getActivity().getResources().getDisplayMetrics().density;
-            return Math.round(dp * density);
-        }
-
-        void postMessageToWebView(String jsonString) {
-            String js = "(function() { " +
-                    "if (window.__sandboxBridge && window.__sandboxBridge.onMessage) { " +
-                    "window.__sandboxBridge.onMessage(" + jsonString + "); " +
-                    "} " +
-                    "})();";
-            webView.evaluateJavascript(js, null);
-        }
-
-        void resolveRequest(String requestId, int status, String statusText,
-                            Map<String, String> headers, String bodyBase64) {
-            PendingRequest pending = pendingRequests.remove(requestId);
-            if (pending == null) return;
-
-            byte[] bodyBytes = null;
-            if (bodyBase64 != null && !bodyBase64.equals("null")) {
-                try {
-                    bodyBytes = Base64.decode(bodyBase64, Base64.DEFAULT);
-                } catch (Exception e) {
-                    Log.w(TAG, "Base64 decode failed for request " + requestId, e);
-                }
-            }
-
-            String contentType = headers.getOrDefault("Content-Type", "application/octet-stream");
-            String encoding = contentType.contains("text/") ? "UTF-8" : null;
-
-            InputStream body = bodyBytes != null
-                    ? new ByteArrayInputStream(bodyBytes)
-                    : new ByteArrayInputStream(new byte[0]);
-
-            WebResourceResponse response = new WebResourceResponse(
-                    contentType, encoding, status, statusText, headers, body
-            );
-
-            pending.resolve(response);
-        }
-    }
-
-    /**
-     * WebViewClient that intercepts all requests and forwards them to JS.
-     */
-    private static class SandboxWebViewClient extends WebViewClient {
-        private final SandboxInstance sandbox;
-        private boolean bridgeInjected = false;
-
-        SandboxWebViewClient(SandboxInstance sandbox) {
-            this.sandbox = sandbox;
-        }
-
-        @Override
-        public WebResourceResponse shouldInterceptRequest(WebView view, WebResourceRequest request) {
-            String url = request.getUrl().toString();
-
-            // Only intercept requests to the sandbox domain.
-            if (!url.contains(".sandbox.native")) {
-                return null;
-            }
-
-            String requestId = UUID.randomUUID().toString();
-
-            // Create a pending request with a blocking latch.
-            PendingRequest pending = new PendingRequest();
-            sandbox.pendingRequests.put(requestId, pending);
-
-            // Rewrite URL to include the sandbox ID for the JS handler.
-            String path = request.getUrl().getPath();
-            if (path == null || path.isEmpty()) path = "/";
-            String rewrittenURL = "https://" + sandbox.id + ".sandbox.native" + path;
-
-            // Serialise the request.
-            JSObject serialisedRequest = new JSObject();
-            serialisedRequest.put("url", rewrittenURL);
-            serialisedRequest.put("method", request.getMethod());
-
-            JSObject headers = new JSObject();
-            for (Map.Entry<String, String> entry : request.getRequestHeaders().entrySet()) {
-                headers.put(entry.getKey(), entry.getValue());
-            }
-            serialisedRequest.put("headers", headers);
-            serialisedRequest.put("body", JSONObject.NULL);
-
-            // Emit to JS.
-            sandbox.plugin.emitFetchRequest(sandbox.id, requestId, serialisedRequest);
-
-            // Block until JS responds. Each asset is fetched from a Blossom
-            // server over the network, so we need a generous timeout.  The
-            // WebView IO thread pool has ~6 threads; if all are blocked,
-            // subsequent requests queue until a thread frees up.
-            WebResourceResponse response = pending.awaitResponse(60000);
-
-            if (response != null) {
-                return response;
-            }
-
-            // Timeout — return error response.
-            sandbox.pendingRequests.remove(requestId);
-            return new WebResourceResponse(
-                    "text/plain", "UTF-8", 504,
-                    "Gateway Timeout", new HashMap<>(),
-                    new ByteArrayInputStream("Request timed out".getBytes())
-            );
-        }
-
-        @Override
-        public void onPageFinished(WebView view, String url) {
-            super.onPageFinished(view, url);
-
-            if (!bridgeInjected) {
-                bridgeInjected = true;
-                view.evaluateJavascript(getBridgeScript(), null);
-            }
-
-            // Remove the native spinner once the first page has finished
-            // loading (all initial resources resolved). This runs on the
-            // main thread, so the removal is safe.
-            sandbox.hideSpinner();
-        }
-
-        private String getBridgeScript() {
-            return "(function() {" +
-                    "'use strict';" +
-                    "var messageListeners = [];" +
-                    "window.__sandboxBridge = {" +
-                    "  onMessage: function(data) {" +
-                    "    var event = {" +
-                    "      data: data," +
-                    "      origin: 'https://" + sandbox.id + ".sandbox.native'," +
-                    "      source: window.parent," +
-                    "      type: 'message'" +
-                    "    };" +
-                    "    for (var i = 0; i < messageListeners.length; i++) {" +
-                    "      try { messageListeners[i](event); } catch(e) {}" +
-                    "    }" +
-                    "  }" +
-                    "};" +
-                    "var origAdd = window.addEventListener;" +
-                    "window.addEventListener = function(type, fn, opts) {" +
-                    "  if (type === 'message' && typeof fn === 'function') messageListeners.push(fn);" +
-                    "  return origAdd.call(window, type, fn, opts);" +
-                    "};" +
-                    "var origRemove = window.removeEventListener;" +
-                    "window.removeEventListener = function(type, fn, opts) {" +
-                    "  if (type === 'message') {" +
-                    "    var idx = messageListeners.indexOf(fn);" +
-                    "    if (idx !== -1) messageListeners.splice(idx, 1);" +
-                    "  }" +
-                    "  return origRemove.call(window, type, fn, opts);" +
-                    "};" +
-                    "if (!window.parent || window.parent === window) window.parent = {};" +
-                    "window.parent.postMessage = function(data) {" +
-                    "  if (data && typeof data === 'object' && data.jsonrpc === '2.0') {" +
-                    "    try { window.__sandboxNative.postMessage(JSON.stringify(data)); } catch(e) {}" +
-                    "  }" +
-                    "};" +
-                    "})();";
-        }
-    }
-
-    /**
-     * JavaScript interface exposed to the sandbox WebView.
-     */
-    private static class SandboxBridge {
-        private final SandboxInstance sandbox;
-
-        SandboxBridge(SandboxInstance sandbox) {
-            this.sandbox = sandbox;
-        }
-
-        @JavascriptInterface
-        public void postMessage(String json) {
-            try {
-                JSONObject obj = new JSONObject(json);
-                JSObject jsObj = new JSObject();
-                for (java.util.Iterator<String> it = obj.keys(); it.hasNext(); ) {
-                    String key = it.next();
-                    jsObj.put(key, obj.get(key));
-                }
-                sandbox.plugin.emitScriptMessage(sandbox.id, jsObj);
-            } catch (JSONException e) {
-                Log.w(TAG, "Failed to parse script message", e);
-            }
-        }
-    }
-
-    /**
-     * A pending request that blocks the WebViewClient IO thread until JS
-     * responds with the complete resource.
-     */
-    private static class PendingRequest {
-        private volatile WebResourceResponse response;
-        private final CountDownLatch latch = new CountDownLatch(1);
-
-        void resolve(WebResourceResponse response) {
-            this.response = response;
-            latch.countDown();
-        }
-
-        WebResourceResponse awaitResponse(long timeoutMs) {
-            try {
-                latch.await(timeoutMs, TimeUnit.MILLISECONDS);
-            } catch (InterruptedException e) {
-                Thread.currentThread().interrupt();
-            }
-            return response;
-        }
-    }
-}

android/app/src/main/res/values/strings.xml

@@ -1,7 +1,7 @@
 <?xml version='1.0' encoding='utf-8'?>
 <resources>
-    <string name="app_name">Ditto</string>
-    <string name="title_activity_main">Ditto</string>
-    <string name="package_name">pub.ditto.app</string>
-    <string name="custom_url_scheme">pub.ditto.app</string>
+    <string name="app_name">Agora</string>
+    <string name="title_activity_main">Agora</string>
+    <string name="package_name">pub.agora.app</string>
+    <string name="custom_url_scheme">pub.agora.app</string>
 </resources>

android/app/src/main/res/xml/backup_rules.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Android Auto Backup rules (Android 11 and below).
+
+    Ditto excludes WebView storage (Local Storage, IndexedDB, databases) and
+    any shared_prefs that hold sensitive credentials so they don't end up in
+    Google Drive backups. Keychain/KeyStore entries used by
+    capacitor-secure-storage-plugin are not backed up by default, so we don't
+    need to exclude those explicitly; but we also exclude the plugin's
+    SharedPreferences for defense in depth.
+
+    See: https://developer.android.com/guide/topics/data/autobackup
+-->
+<full-backup-content>
+    <!-- WebView: localStorage, IndexedDB, cookies, caches -->
+    <exclude domain="file" path="app_webview/" />
+    <exclude domain="database" path="webview.db" />
+    <exclude domain="database" path="webviewCache.db" />
+
+    <!-- capacitor-secure-storage-plugin fallback SharedPreferences -->
+    <exclude domain="sharedpref" path="CapacitorSecureStoragePluginSharedPreferences.xml" />
+
+    <!-- Capacitor preferences plugin — may contain app-level settings -->
+    <exclude domain="sharedpref" path="CapacitorStorage.xml" />
+</full-backup-content>

android/app/src/main/res/xml/data_extraction_rules.xml

@@ -0,0 +1,26 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Android 12+ data extraction rules.
+
+    Separate rules apply to cloud backups (Google Drive) and device-to-device
+    transfers. Both exclude WebView storage and sensitive SharedPreferences so
+    wallet credentials, login tokens, and cached private data don't leak.
+
+    See: https://developer.android.com/about/versions/12/backup-restore
+-->
+<data-extraction-rules>
+    <cloud-backup>
+        <exclude domain="file" path="app_webview/" />
+        <exclude domain="database" path="webview.db" />
+        <exclude domain="database" path="webviewCache.db" />
+        <exclude domain="sharedpref" path="CapacitorSecureStoragePluginSharedPreferences.xml" />
+        <exclude domain="sharedpref" path="CapacitorStorage.xml" />
+    </cloud-backup>
+    <device-transfer>
+        <exclude domain="file" path="app_webview/" />
+        <exclude domain="database" path="webview.db" />
+        <exclude domain="database" path="webviewCache.db" />
+        <exclude domain="sharedpref" path="CapacitorSecureStoragePluginSharedPreferences.xml" />
+        <exclude domain="sharedpref" path="CapacitorStorage.xml" />
+    </device-transfer>
+</data-extraction-rules>

capacitor.config.ts

@@ -1,8 +1,8 @@
 import type { CapacitorConfig } from '@capacitor/cli';
 
 const config: CapacitorConfig = {
-  appId: 'pub.ditto.app',
-  appName: 'Ditto',
+  appId: 'pub.agora.app',
+  appName: 'Agora',
   webDir: 'dist',
   server: {
     androidScheme: 'https',
@@ -16,7 +16,7 @@ const config: CapacitorConfig = {
   ios: {
     backgroundColor: '#14161f',
     contentInset: 'never',
-    scheme: 'Ditto'
+    scheme: 'Agora'
   },
   plugins: {
     SystemBars: {

docker-compose.prod.yml

@@ -0,0 +1,6 @@
+services:
+  web:
+    build: .
+    restart: unless-stopped
+    expose:
+      - "80"

docker-compose.yml

@@ -0,0 +1,30 @@
+services:
+  web:
+    image: nginx:alpine
+    ports:
+      - "8083:80"
+    volumes:
+      - ./nginx.dev.conf:/etc/nginx/conf.d/default.conf:ro
+      - ./dist:/usr/share/nginx/html:ro
+    restart: unless-stopped
+    depends_on:
+      - vite
+    networks:
+      - agora-network
+
+  vite:
+    image: node:22-alpine
+    working_dir: /app
+    # Use host node_modules so new dependencies are picked up after install.
+    command: sh -c "npm install && npm run dev"
+    volumes:
+      - .:/app
+    environment:
+      - NODE_ENV=development
+    networks:
+      - agora-network
+    restart: unless-stopped
+
+networks:
+  agora-network:
+    driver: bridge

docs/THEME_SYSTEM.md

@@ -1,383 +0,0 @@
-# Theme System
-
-This document describes the two separate but overlapping theme features in Ditto: the **App Theme** (which controls the local UI) and the **Profile Theme** (which is published to Nostr for others to see). Understanding the distinction is key to working with this codebase.
-
-## Overview
-
-| Concept | Purpose | Scope | Persistence |
-|---|---|---|---|
-| **App Theme** | Controls colors, fonts, and background of the local UI | Local to the user's browser | localStorage + encrypted NIP-78 sync |
-| **Profile Theme** | A set of theme values published as a Nostr event | Public, visible to other users | Kind 16767 replaceable event |
-
-The App Theme and Profile Theme share the same underlying data structure (`ThemeConfig`), and there is an optional bridge between them (`autoShareTheme`), but they are fundamentally independent systems.
-
----
-
-## Part 1: App Theme
-
-The App Theme controls what the user sees in their own browser. It has no inherent connection to Nostr.
-
-### Core Concept: 3 Colors Define Everything
-
-The entire theme is derived from just 3 core colors, defined by the `CoreThemeColors` interface in `src/themes.ts:8`:
-
-```typescript
-interface CoreThemeColors {
-  background: string;  // HSL string, e.g. "228 20% 10%"
-  text: string;        // Text/foreground color
-  primary: string;     // Primary accent (buttons, links, focus rings)
-}
-```
-
-From these 3 values, the system auto-derives 19 CSS tokens (the full `ThemeTokens` set) via `deriveTokensFromCore()` in `src/lib/colorUtils.ts:141`. The derivation algorithm:
-
-- Detects dark/light mode from background luminance (threshold: 0.2)
-- Derives `card` and `popover` surfaces by slightly lightening the background (dark mode) or using it directly (light mode)
-- Derives `secondary` and `muted` surfaces by adjusting background lightness
-- Derives `border` using the primary hue with reduced saturation
-- Computes `mutedForeground` as a dimmer version of the text color
-- Sets `accent = primary` and `ring = primary`
-- Auto-computes `primaryForeground` using WCAG contrast detection (white or dark)
-- Uses fixed red values for `destructive` / `destructiveForeground`
-
-### Theme Modes
-
-The `Theme` type (`src/contexts/AppContext.ts:9`) has four values:
-
-| Mode | Behavior |
-|---|---|
-| `"light"` | Uses the builtin (or configured) light color set |
-| `"dark"` | Uses the builtin (or configured) dark color set |
-| `"system"` | Resolves to `"light"` or `"dark"` based on `prefers-color-scheme`, with a live media query listener |
-| `"custom"` | Uses user-defined colors stored in `config.customTheme` |
-
-**Builtin themes** are defined in `src/themes.ts:102`:
-
-```typescript
-const builtinThemes = {
-  light: { background: '270 50% 97%', text: '270 25% 12%', primary: '270 65% 55%' },
-  dark:  { background: '228 20% 10%', text: '210 40% 98%', primary: '258 70% 60%' },
-};
-```
-
-Self-hosters can override these at build time via `ditto.json` (injected through `import.meta.env.DITTO_CONFIG` in `vite.config.ts`), or at runtime via the `ThemesConfig` in `AppConfig.themes`.
-
-### ThemeConfig
-
-The `ThemeConfig` type (`src/themes.ts:50`) wraps the 3 core colors with optional extras:
-
-```typescript
-interface ThemeConfig {
-  title?: string;
-  colors: CoreThemeColors;
-  font?: ThemeFont;        // { family: string; url?: string }
-  background?: ThemeBackground;  // { url: string; mode?: 'cover' | 'tile'; ... }
-}
-```
-
-This is the canonical type used everywhere: in `AppConfig.customTheme`, in encrypted settings, and in Nostr theme events.
-
-### Theme Presets
-
-Named presets are defined in `src/themes.ts:136` (e.g. `pink`, `toxic`, `sunset`). Each preset includes core colors and optionally a font and background image. Applying a preset sets the app theme to `"custom"` and stores the preset's config as `customTheme`.
-
-### How Themes Apply to the DOM
-
-The theme pipeline has three stages designed to prevent any flash of wrong colors:
-
-#### Stage 1: Pre-React Blocking Script (`public/theme.js`)
-
-A synchronous `<script>` tag in `index.html:43` runs before React mounts. It:
-
-1. Reads `nostr:app-config` from localStorage
-2. Resolves `"system"` via `matchMedia`
-3. Handles legacy presets (`"black"`, `"pink"`)
-4. Sets `document.documentElement.className` to the theme name
-5. Sets `document.body.style.background` to the correct background color
-6. Updates preloader colors (logo and spinner) to match
-
-This prevents any visible flash between the hardcoded dark defaults in `index.html:32` and the user's actual theme.
-
-#### Stage 2: React Provider (`src/components/AppProvider.tsx`)
-
-Three private hooks run during the provider's lifecycle:
-
-**`useApplyTheme`** (line 91) - Uses `useLayoutEffect` (synchronous before paint) to:
-- Resolve the theme mode
-- Build a full CSS string from `CoreThemeColors` via `buildThemeCssFromCore()`
-- Inject/update a `<style id="theme-vars">` element with all 19 CSS custom properties
-- Set `document.documentElement.className` to the resolved theme
-- Remove the inline body style left by `theme.js`
-- When mode is `"system"`, attach a `matchMedia` change listener
-
-**`useApplyFonts`** (line 133) - Loads and applies custom fonts via `loadAndApplyFont()` from `src/lib/fontLoader.ts`.
-
-**`useApplyBackground`** (line 156) - Injects/removes a `<style id="theme-background">` for background images (cover or tile mode).
-
-#### Stage 3: Theme Switch (`src/hooks/useTheme.ts`)
-
-The `setTheme()` function (line 52) performs a flicker-free theme switch:
-
-1. Injects a temporary `<style>` that disables all CSS transitions (`transition: none !important`)
-2. Synchronously builds and applies CSS vars before React re-renders
-3. Updates `document.documentElement.className`
-4. Re-enables transitions after browser paint via `requestAnimationFrame`
-5. Updates localStorage config
-6. Debounce-syncs to encrypted NIP-78 storage (1 second delay)
-
-### How Components Consume Theme Values
-
-#### CSS Custom Properties to Tailwind
-
-`tailwind.config.ts` maps all 19 CSS custom properties to Tailwind color utilities:
-
-```typescript
-colors: {
-  background: 'hsl(var(--background))',
-  foreground: 'hsl(var(--foreground))',
-  primary: { DEFAULT: 'hsl(var(--primary))', foreground: 'hsl(var(--primary-foreground))' },
-  // ... (secondary, destructive, muted, accent, popover, card, border, input, ring)
-}
-```
-
-Components use standard Tailwind classes like `bg-primary`, `text-foreground`, `border-border`, etc. These resolve to `hsl(var(--primary))`, which picks up whichever values are currently set on `:root`.
-
-The `cn()` utility in `src/lib/utils.ts` combines `clsx` (conditional class joining) with `tailwind-merge` (intelligent Tailwind class deduplication).
-
-#### Static CSS
-
-`src/index.css` applies base styles using theme tokens:
-
-```css
-* { @apply border-border; }
-body { @apply bg-background text-foreground; }
-```
-
-The only static CSS custom property is `--radius: 0.75rem`. All color variables are injected dynamically.
-
-### ScopedTheme
-
-The `ScopedTheme` component (`src/components/ScopedTheme.tsx`) applies a different set of theme colors to a DOM subtree by setting CSS variables as inline `style`:
-
-```tsx
-<ScopedTheme colors={someColors} className="rounded-lg p-4">
-  {/* Children here see different --background, --primary, etc. */}
-</ScopedTheme>
-```
-
-It also sets `data-theme-mode="dark"` or `"light"` based on background luminance, for CSS targeting.
-
-### App Theme Persistence
-
-#### Layer 1: localStorage (immediate)
-
-The `useLocalStorage` hook (`src/hooks/useLocalStorage.ts`) stores the full `AppConfig` under key `"nostr:app-config"`. This includes `theme`, `customTheme`, `autoShareTheme`, and `themes`. Changes are reflected immediately and support cross-tab sync via `StorageEvent`.
-
-#### Layer 2: Encrypted NIP-78 Settings (cross-device sync)
-
-The `useEncryptedSettings` hook (`src/hooks/useEncryptedSettings.ts`) stores theme preferences in a kind 30078 addressable event, encrypted to self via NIP-44. The `EncryptedSettings` interface includes `theme`, `customTheme`, and `autoShareTheme` among other app settings.
-
-Key behaviors:
-- Query is delayed 5 seconds after login to avoid competing with feed load
-- Uses optimistic updates with a `pendingSettings` ref for rapid successive mutations
-- A `recentlyWritten()` guard returns true for 10 seconds after a local write to prevent `NostrSync` from overwriting the value that was just saved
-
-#### Sync via NostrSync
-
-The `NostrSync` component (`src/components/NostrSync.tsx`) runs globally and syncs encrypted settings from Nostr on login. For theme-related fields, it:
-
-1. Seeds a `lastSyncedTimestamp` ref on first load to prevent stale events from overwriting local config
-2. Skips application if `recentlyWritten()` is true
-3. Only applies changes if the remote timestamp is newer
-4. Handles legacy theme value migration (`"black"`, `"pink"` to `"custom"`)
-5. Diffs each field individually to avoid unnecessary re-renders
-
----
-
-## Part 2: Profile Theme
-
-The Profile Theme is a public Nostr event that represents a user's chosen theme. Other clients can read it to style that user's profile page, or users can browse and copy each other's themes.
-
-### Nostr Event Kinds
-
-#### Kind 36767: Theme Definition (addressable, multiple per user)
-
-A shareable, named theme that a user has created. Think of these as "published theme presets." Tags:
-
-| Tag | Purpose | Example |
-|---|---|---|
-| `d` | Identifier (slug) | `["d", "ocean-night"]` |
-| `c` | Color (hex + role) | `["c", "#1a1a2e", "background"]` |
-| `f` | Font (family + optional URL) | `["f", "Comfortaa", "https://cdn.jsdelivr.net/..."]` |
-| `bg` | Background (imeta-style variadic) | `["bg", "url https://...", "mode cover", "m image/jpeg"]` |
-| `title` | Display name | `["title", "Ocean Night"]` |
-| `alt` | NIP-31 description | `["alt", "Custom theme: Ocean Night"]` |
-| `t` | Topic tag | `["t", "theme"]` |
-| `description` | Optional description | `["description", "A deep blue theme"]` |
-
-Colors are stored as **hex** in `c` tags (converted to/from HSL internally). The `content` field is empty (legacy events may have JSON in content for backward compatibility).
-
-#### Kind 16767: Active Profile Theme (replaceable, one per user)
-
-The user's currently active profile theme. Same tag structure as kind 36767 but without `d` or `description` tags, and with an optional `a` tag referencing the source theme definition:
-
-| Tag | Purpose |
-|---|---|
-| `c` | Color tags (same as 36767) |
-| `f` | Font tag (same as 36767) |
-| `bg` | Background tag (same as 36767) |
-| `alt` | Always `"Active profile theme"` |
-| `title` | Optional theme name |
-| `a` | Optional reference to source kind 36767 event |
-
-### Hooks
-
-| Hook | File | Purpose |
-|---|---|---|
-| `usePublishTheme` | `src/hooks/usePublishTheme.ts` | Publish/update/delete theme definitions (36767), set/clear active profile theme (16767) |
-| `useUserThemes` | `src/hooks/useUserThemes.ts` | Query all kind 36767 themes by a user, deduplicated by d-tag, sorted newest first |
-| `useActiveProfileTheme` | `src/hooks/useActiveProfileTheme.ts` | Query a user's kind 16767 active profile theme |
-
-### Publishing and Parsing
-
-All event building and parsing is in `src/lib/themeEvent.ts`:
-
-- `buildThemeDefinitionTags()` / `parseThemeDefinition()` - Kind 36767
-- `buildActiveThemeTags()` / `parseActiveProfileTheme()` - Kind 16767
-- `buildColorTags()` / `parseColorTags()` - HSL-to-hex conversion for `c` tags
-- `buildFontTag()` / `parseFontTag()` - Font `f` tags
-- `buildBackgroundTag()` / `parseBackgroundTag()` - Background `bg` tags (imeta-style)
-- `titleToSlug()` - Generate d-tag identifiers from titles
-
-Backward compatibility: if `c` tags are missing, the parser falls back to reading legacy JSON from `content` (handling both the old 19-token format and the 4-color format).
-
----
-
-## Part 3: The Bridge Between App Theme and Profile Theme
-
-The two systems are connected by the **autoShareTheme** setting and the NostrSync component.
-
-### App Theme -> Profile Theme
-
-When `autoShareTheme` is enabled (default: `true`) and the user applies a custom theme via `applyCustomTheme()`, the `useTheme` hook automatically publishes the custom theme as a kind 16767 active profile theme, debounced by 2 seconds.
-
-```
-User picks a custom theme
-  -> applyCustomTheme() in useTheme.ts:88
-    -> Updates local config (localStorage)
-    -> Syncs to encrypted NIP-78 storage (1s debounce)
-    -> If autoShareTheme: publishes kind 16767 (2s debounce)
-```
-
-### Profile Theme -> App Theme
-
-On page load, if `autoShareTheme` is enabled, `NostrSync` (line 174) fetches the user's kind 16767 event and applies it as `customTheme` **without changing the theme mode**. This means:
-
-- If the user is on `theme: "dark"`, their profile theme is stored as `customTheme` but the UI stays in dark mode
-- If the user is on `theme: "custom"`, the profile theme's colors are applied to the UI
-- This allows the profile theme to stay in sync across devices without forcing the user into custom mode
-
-### Theme Definitions (Kind 36767)
-
-Theme definitions are independent of the app theme. Users can create, publish, edit, and delete named themes. Other users can view them in feeds (via `ThemeUpdateCard`) and copy them. These are purely social objects on the Nostr network.
-
----
-
-## Font System
-
-Fonts are managed by `src/lib/fontLoader.ts` and `src/lib/fonts.ts`.
-
-### Bundled Fonts
-
-10 fonts are bundled via `@fontsource` packages with lazy loading (dynamic imports):
-
-| Category | Fonts |
-|---|---|
-| Sans | Inter, DM Sans, Outfit, Montserrat |
-| Serif | Lora, Merriweather, Playfair Display |
-| Mono | JetBrains Mono |
-| Display | Comfortaa |
-| Handwriting | Comic Relief |
-
-Each has a `load()` function and a `cdnUrl` for Nostr event publishing.
-
-### Font Application
-
-Three `<style>` elements manage fonts:
-
-| ID | Purpose |
-|---|---|
-| `theme-font-faces` | `@font-face` rules for remote fonts |
-| `theme-font-overrides` | `html { font-family: "CustomFont", "Inter Variable", ... !important; }` |
-| `theme-vars` | Theme CSS custom properties (not font-specific, but part of the pipeline) |
-
-The `loadAndApplyFont()` function:
-1. Tries to load via bundled `@fontsource` package first
-2. Falls back to injecting a `@font-face` rule from a remote URL
-3. Applies a global font-family override via `<style id="theme-font-overrides">`
-4. Passing `undefined` clears the override (reverts to default Inter)
-
----
-
-## Color Utilities
-
-`src/lib/colorUtils.ts` provides the color math underpinning the theme system:
-
-| Function | Purpose |
-|---|---|
-| `parseHsl` / `formatHsl` | Parse/format HSL strings (`"228 20% 10%"`) |
-| `hslToRgb` / `rgbToHsl` | HSL-RGB conversion |
-| `hexToRgb` / `rgbToHex` | Hex-RGB conversion |
-| `hexToHslString` / `hslStringToHex` | Direct hex-to-HSL-string conversion (used for Nostr `c` tags) |
-| `getLuminance` | WCAG 2.1 relative luminance |
-| `getContrastRatio` / `getContrastRatioHsl` | WCAG contrast ratio between two colors |
-| `isDarkTheme` | Determines if a background is "dark" (luminance < 0.2) |
-| `deriveTokensFromCore` | The core algorithm: 3 colors -> 19 tokens |
-| `tokensToCoreColors` | Extract 3 core colors from a legacy 19-token object |
-
-All colors are stored internally as HSL strings without the `hsl()` wrapper (e.g. `"228 20% 10%"`). The `hsl()` wrapper is added by Tailwind's config (`hsl(var(--background))`).
-
----
-
-## Validation
-
-Theme data is validated with Zod schemas in `src/lib/schemas.ts`:
-
-- `ThemeSchema` - Validates `'dark' | 'light' | 'system' | 'custom'`
-- `CoreThemeColorsSchema` - Validates the 3 HSL string fields
-- `ThemeConfigSchema` - Full config with optional font/background
-- `ThemeConfigCompatSchema` - Accepts both `ThemeConfig` and bare `CoreThemeColors`
-- `ThemeColorsCompatSchema` - Union of current 3-color, old 4-color, and legacy 19-token formats
-- `AppConfigSchema` - Full app config including all theme fields
-- `EncryptedSettingsSchema` - Encrypted settings including theme fields
-
-The `AppProvider` deserializer (`src/components/AppProvider.tsx:32`) validates each top-level field individually with `safeParse`, so a single invalid field doesn't nuke the entire config.
-
----
-
-## File Index
-
-| File | Role |
-|---|---|
-| `src/themes.ts` | Core types (`CoreThemeColors`, `ThemeConfig`, `ThemeTokens`), builtin themes, presets, CSS builders |
-| `src/lib/colorUtils.ts` | Color conversion, contrast detection, token derivation |
-| `src/lib/themeEvent.ts` | Nostr event kinds (36767, 16767), tag building/parsing |
-| `src/lib/fontLoader.ts` | Font loading and CSS injection |
-| `src/lib/fonts.ts` | Bundled font definitions |
-| `src/lib/schemas.ts` | Zod validation schemas |
-| `src/contexts/AppContext.ts` | `Theme` type, `AppConfig` interface, React context |
-| `src/hooks/useTheme.ts` | Primary theme API: `setTheme()`, `applyCustomTheme()`, `setAutoShareTheme()` |
-| `src/hooks/useAppContext.ts` | Context consumer hook |
-| `src/hooks/useEncryptedSettings.ts` | NIP-78 encrypted settings (cross-device sync) |
-| `src/hooks/usePublishTheme.ts` | Publish theme definitions and active profile theme |
-| `src/hooks/useUserThemes.ts` | Query user's theme definitions |
-| `src/hooks/useActiveProfileTheme.ts` | Query user's active profile theme |
-| `src/components/AppProvider.tsx` | Theme application to DOM (`useApplyTheme`, `useApplyFonts`, `useApplyBackground`) |
-| `src/components/NostrSync.tsx` | Cross-device sync for encrypted settings and profile theme |
-| `src/components/ScopedTheme.tsx` | Scoped CSS variable overrides for subtrees |
-| `src/components/ThemeSelector.tsx` | Full settings UI for theme management |
-| `src/components/SidebarThemeDropdown.tsx` | Compact theme picker dropdown |
-| `public/theme.js` | Pre-React blocking script for flash prevention |
-| `index.html` | Hardcoded dark defaults, preloader, blocking script tag |
-| `tailwind.config.ts` | CSS custom property to Tailwind color mapping |
-| `src/index.css` | Base styles using theme tokens |

docs/blobbi/blobbi-tag-schema.md

@@ -1,254 +0,0 @@
-# Blobbi Tag Schema
-
-> **Product Specification** - This document is the canonical source of truth for Blobbi tag definitions.  
-> The runtime schema at `src/lib/blobbi-tag-schema.ts` MUST align with this spec.
-
-## Overview
-
-Blobbi events (Kind 31124) use tags to store all state data. This document defines:
-- All valid tags and their purposes
-- Which tags are required vs optional
-- Which tags persist across stage transitions
-- Which tags should be removed during transitions
-- Deprecated tags that should be filtered out
-
----
-
-## Tag Categories
-
-### 1. System / Metadata Tags
-
-Core protocol-level tags required for event identification and ecosystem membership.
-
-| Tag | Required | Stages | Persistent | Source | Format | Description |
-|-----|----------|--------|------------|--------|--------|-------------|
-| `d` | **Yes** | egg, baby, adult | Yes | system | `blobbi-{pubkeyPrefix12}-{petId10}` | Unique identifier (addressable event d-tag) |
-| `b` | **Yes** | egg, baby, adult | Yes | system | `blobbi:ecosystem:v1` | Ecosystem namespace identifier |
-| `t` | **Yes** | egg, baby, adult | Yes | system | `blobbi` | Topic tag for discoverability |
-| `client` | No | egg, baby, adult | Yes | system | `blobbi` | Client identifier |
-
-### 2. Core Identity Tags
-
-Tags that define the Blobbi's unique identity. These MUST be preserved across all transitions.
-
-| Tag | Required | Stages | Persistent | Source | Format | Description |
-|-----|----------|--------|------------|--------|--------|-------------|
-| `name` | **Yes** | egg, baby, adult | Yes | user | string | Display name (set during adoption) |
-| `seed` | **Yes** | egg, baby, adult | Yes | system | 64 hex chars | Deterministic seed for visual traits |
-| `generation` | No | egg, baby, adult | Yes | system | positive integer | Lineage generation (default: 1) |
-
-**Important**: The `seed` is derived once at creation using `sha256("blobbi:v1|{pubkey}:{d}:{createdAt}")` and MUST NEVER be recomputed.
-
-### 3. Visual Trait Tags
-
-Tags derived deterministically from the seed. These are stored explicitly for fast rendering and compatibility.
-
-| Tag | Required | Stages | Persistent | Source | Format | Description |
-|-----|----------|--------|------------|--------|--------|-------------|
-| `base_color` | No | egg, baby, adult | Yes | generated | CSS hex (e.g., `#F59E0B`) | Primary color |
-| `secondary_color` | No | egg, baby, adult | Yes | generated | CSS hex | Secondary/accent color |
-| `eye_color` | No | egg, baby, adult | Yes | generated | CSS hex | Eye color |
-| `pattern` | No | egg, baby, adult | Yes | generated | `solid\|spotted\|striped\|gradient` | Visual pattern type |
-| `special_mark` | No | egg, baby, adult | Yes | generated | `none\|star\|heart\|sparkle\|blush` | Special decoration |
-| `size` | No | egg, baby, adult | Yes | generated | `small\|medium\|large` | Size category |
-
-**Regenerable**: These tags CAN be regenerated from the seed if missing. However, they should be preserved when present.
-
-### 4. Personality / Trait Tags
-
-Character traits that define the Blobbi's personality. These are generated at creation and MUST persist.
-
-| Tag | Required | Stages | Persistent | Source | Format | Description |
-|-----|----------|--------|------------|--------|--------|-------------|
-| `personality` | No | egg, baby, adult | Yes | generated | string | Core personality type |
-| `trait` | No | egg, baby, adult | Yes | generated | string | Character trait modifier |
-| `favorite_food` | No | egg, baby, adult | Yes | generated | string | Preferred food type |
-| `voice_type` | No | egg, baby, adult | Yes | generated | string | Voice characteristic |
-| `mood` | No | egg, baby, adult | Yes | computed | string | Current emotional state |
-
-**Not Regenerable**: These tags are generated once and MUST be preserved. Do NOT invent values for existing Blobbis that lack these tags.
-
-### 5. Stat Tags
-
-Numeric values representing the Blobbi's current condition. These are actively computed and change frequently.
-
-| Tag | Required | Stages | Persistent | Source | Format | Default | Description |
-|-----|----------|--------|------------|--------|--------|---------|-------------|
-| `hunger` | No | egg, baby, adult | No | computed | 1-100 | 100 | Fullness level |
-| `happiness` | No | egg, baby, adult | No | computed | 1-100 | 100 | Happiness level |
-| `health` | No | egg, baby, adult | No | computed | 1-100 | 100 | Health level |
-| `hygiene` | No | egg, baby, adult | No | computed | 1-100 | 100 | Cleanliness level |
-| `energy` | No | egg, baby, adult | No | computed | 1-100 | 100 | Energy level |
-
-**Stage Transition Behavior**:
-- **Hatch (egg → baby)**: `health` inherited from egg, others reset to 100
-- **Evolve (baby → adult)**: All stats inherited from baby (after decay)
-
-### 6. State / Lifecycle Tags
-
-Tags that track the Blobbi's current lifecycle state.
-
-| Tag | Required | Stages | Persistent | Source | Format | Description |
-|-----|----------|--------|------------|--------|--------|-------------|
-| `stage` | **Yes** | egg, baby, adult | No | system | `egg\|baby\|adult` | Current lifecycle stage |
-| `state` | **Yes** | egg, baby, adult | No | system | `active\|sleeping\|hibernating\|incubating\|evolving` | Activity state |
-| `last_interaction` | **Yes** | egg, baby, adult | No | system | Unix timestamp | Last user action |
-| `last_decay_at` | No | egg, baby, adult | No | system | Unix timestamp | Decay checkpoint |
-
-**State Constraints**:
-- `incubating` is only valid for `stage: egg`
-- `evolving` is only valid for `stage: baby`
-- After hatch/evolve completes, `state` MUST be set to `active`
-
-### 7. Task System Tags
-
-Temporary tags used during incubation and evolution processes. These are REMOVED after stage transitions.
-
-| Tag | Required | Stages | Persistent | Source | Format | Description |
-|-----|----------|--------|------------|--------|--------|-------------|
-| `state_started_at` | No | egg, baby | No | system | Unix timestamp | When incubating/evolving started |
-| `task` | No | egg, baby | No | computed | `["task", "name:value"]` | Task progress (multiple allowed) |
-| `task_completed` | No | egg, baby | No | computed | `["task_completed", "name"]` | Completed tasks (multiple allowed) |
-
-**Transition Behavior**: ALL task system tags MUST be removed when hatch or evolve completes.
-
-### 8. Progression Tags
-
-Long-term progress tracking that persists across all stages.
-
-| Tag | Required | Stages | Persistent | Source | Format | Default | Description |
-|-----|----------|--------|------------|--------|--------|---------|-------------|
-| `experience` | No | egg, baby, adult | Yes | computed | non-negative int | 0 | Total XP |
-| `care_streak` | No | egg, baby, adult | Yes | computed | non-negative int | 0 | Consecutive care days |
-
-### 9. Social / Flag Tags
-
-User preferences and computed flags.
-
-| Tag | Required | Stages | Persistent | Source | Format | Default | Description |
-|-----|----------|--------|------------|--------|--------|---------|-------------|
-| `breeding_ready` | No | egg, baby, adult | Yes | computed | `true\|false` | false | Breeding eligibility |
-
-### 10. Evolution Tags
-
-Tags specific to adult Blobbis.
-
-| Tag | Required | Stages | Persistent | Source | Format | Description |
-|-----|----------|--------|------------|--------|--------|-------------|
-| `adult_type` | No | adult | Yes | computed | string | Evolution form type |
-
-### 11. Extension Tags
-
-Optional tags for themes and crossover features.
-
-| Tag | Required | Stages | Persistent | Source | Format | Description |
-|-----|----------|--------|------------|--------|--------|-------------|
-| `theme` | No | egg, baby, adult | Yes | system | string (e.g., `divine`) | Theme variant |
-| `crossover_app` | No | egg, baby, adult | Yes | system | string (e.g., `divine`) | Crossover app identifier |
-
----
-
-## Deprecated Tags
-
-These tags are from legacy versions and MUST be removed when republishing events.
-
-| Tag | Reason | Replaced By |
-|-----|--------|-------------|
-| `shell_integrity` | Eggs use standard `health` stat | `health` |
-| `egg_temperature` | Warmth handled via UI props | N/A |
-| `incubation_progress` | Replaced by task system | `task`, `task_completed` |
-| `egg_status` | Replaced by standard state | `state` |
-| `fees` | Removed | N/A |
-| `incubation_time` | Uses state_started_at | `state_started_at` |
-| `start_incubation` | Uses state_started_at | `state_started_at` |
-| `interact_6_progress` | Legacy interaction tracking | `["task", "interactions:N"]` |
-
----
-
-## Stage Transition Rules
-
-### Hatch (egg → baby)
-
-**Tags to REMOVE**:
-- `task`
-- `task_completed`
-- `state_started_at`
-
-**Tags to UPDATE**:
-- `stage` → `baby`
-- `state` → `active`
-- `hunger` → `100`
-- `happiness` → `100`
-- `hygiene` → `100`
-- `energy` → `100`
-- `health` → (inherited from egg after decay)
-- `last_interaction` → current timestamp
-- `last_decay_at` → current timestamp
-
-**Tags to PRESERVE (all persistent tags)**:
-- All system tags (`d`, `b`, `t`, `client`)
-- All identity tags (`name`, `seed`, `generation`)
-- All visual tags (colors, pattern, size)
-- All personality tags (if present)
-- All progression tags (`experience`, `care_streak`)
-- All social tags (`breeding_ready`)
-- All extension tags (`theme`, `crossover_app`)
-
-### Evolve (baby → adult)
-
-**Tags to REMOVE**:
-- `task`
-- `task_completed`
-- `state_started_at`
-
-**Tags to UPDATE**:
-- `stage` → `adult`
-- `state` → `active`
-- All stats → (inherited from baby after decay)
-- `last_interaction` → current timestamp
-- `last_decay_at` → current timestamp
-
-**Tags to PRESERVE (all persistent tags)**:
-- Same as hatch, plus all stats are inherited (not reset)
-
-**Tags to ADD (optional)**:
-- `adult_type` → computed based on care history
-
----
-
-## Migration Rules
-
-When migrating legacy Blobbis to canonical format:
-
-1. **Always preserve existing values** - Do not regenerate tags that already exist
-2. **Generate missing required tags** - Derive `seed` if missing using the legacy event's `created_at`
-3. **Remove deprecated tags** - Filter out all tags in the deprecated list
-4. **Repair visual tags** - Regenerate from seed if missing (these are regenerable)
-5. **Do NOT invent personality tags** - If `personality`, `trait`, etc. don't exist, leave them empty
-
----
-
-## Validation Rules
-
-A valid Blobbi event MUST have:
-- `d` tag in canonical format
-- `b` tag = `blobbi:ecosystem:v1`
-- `t` tag = `blobbi`
-- `name` tag (non-empty)
-- `seed` tag (64 hex chars)
-- `stage` tag (valid value)
-- `state` tag (valid value)
-- `last_interaction` tag (valid timestamp)
-
----
-
-## Implementation Checklist
-
-When implementing any flow that modifies Blobbi tags:
-
-- [ ] Start from `canonical.allTags` as the base
-- [ ] Remove only task-specific tags (`task`, `task_completed`, `state_started_at`)
-- [ ] Preserve ALL persistent tags (identity, visual, personality, progression, social, extension)
-- [ ] Filter out deprecated tags
-- [ ] Update only the tags that need to change
-- [ ] Validate required tags are present

eslint.config.js

@@ -8,7 +8,7 @@ import htmlParser from "@html-eslint/parser";
 import customRules from "./eslint-rules/index.js";
 
 export default tseslint.config(
-  { ignores: ["dist", "android", "ios"] },
+  { ignores: ["dist", "android", "ios", ".agents"] },
   {
     extends: [js.configs.recommended, ...tseslint.configs.recommended],
     files: ["**/*.{ts,tsx}"],

index.html

@@ -1,43 +1,45 @@
 <!DOCTYPE html>
 <html lang="en" class="dark">
   <head>
-    <title>Ditto — Your content. Your vibe. Your rules.</title>
+    <title>Agora — Power to the people.</title>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0, viewport-fit=cover, interactive-widget=resizes-content" />
-    <meta name="description" content="Ditto — Your content. Your vibe. Your rules." />
+    <meta name="description" content="Agora — a Nostr social client for communities, creativity, and ownership." />
 
     <!-- Open Graph -->
-    <meta property="og:title" content="Ditto" />
-    <meta property="og:description" content="Your content. Your vibe. Your rules." />
-    <meta property="og:image" content="https://ditto.pub/og-image.jpg" />
+    <meta property="og:title" content="Agora" />
+    <meta property="og:description" content="Power to the people." />
+    <meta property="og:image" content="https://agora.spot/og-image.png" />
     <meta property="og:image:width" content="1200" />
     <meta property="og:image:height" content="630" />
     <meta property="og:image:type" content="image/jpeg" />
     <meta property="og:type" content="website" />
-    <meta property="og:url" content="https://ditto.pub" />
-    <meta property="og:site_name" content="Ditto" />
+    <meta property="og:url" content="https://agora.spot" />
+    <meta property="og:site_name" content="Agora" />
 
     <!-- Twitter / X -->
     <meta name="twitter:card" content="summary_large_image" />
-    <meta name="twitter:title" content="Ditto" />
-    <meta name="twitter:description" content="Your content. Your vibe. Your rules." />
-    <meta name="twitter:image" content="https://ditto.pub/og-image.jpg" />
+    <meta name="twitter:title" content="Agora" />
+    <meta name="twitter:description" content="Power to the people." />
+    <meta name="twitter:image" content="https://agora.spot/og-image.png" />
 
     <meta http-equiv="content-security-policy" content="default-src 'none'; script-src 'self' 'wasm-unsafe-eval'; style-src 'self' 'unsafe-inline'; frame-src 'self' https:; font-src 'self' https:; base-uri 'self'; manifest-src 'self'; connect-src 'self' blob: https: wss:; img-src 'self' data: blob: https:; media-src 'self' blob: https:">
-    <link rel="icon" type="image/svg+xml" href="/logo.svg">
-    <link rel="apple-touch-icon" href="/apple-touch-icon.png">
-    <meta name="theme-color" content="#161b2e" media="(prefers-color-scheme: dark)">
-    <meta name="theme-color" content="#ffffff" media="(prefers-color-scheme: light)">
+    <link rel="icon" type="image/x-icon" href="/favicon.ico">
+    <link rel="icon" type="image/png" sizes="16x16" href="/favicon-16.png">
+    <link rel="icon" type="image/png" sizes="32x32" href="/favicon-32.png">
+    <link rel="apple-touch-icon" sizes="192x192" href="/icon-192.png">
+    <meta name="theme-color" content="#0a0c14" media="(prefers-color-scheme: dark)">
+    <meta name="theme-color" content="#e85d3c" media="(prefers-color-scheme: light)">
     <link rel="manifest" href="/manifest.webmanifest">
-    <style>@keyframes ditto-spin{to{transform:rotate(360deg)}}</style>
+    <style>@keyframes agora-spin{to{transform:rotate(360deg)}}</style>
   </head>
-  <body style="margin:0;background:hsl(228 20% 10%)">
+  <body style="margin:0;background:hsl(0 0% 10%)">
     <!-- Pre-React loading screen. Lives OUTSIDE #root so React doesn't
          touch it. Removed by main.tsx once the app has mounted. -->
-    <div id="preloader" style="position:fixed;inset:0;z-index:9999;display:flex;align-items:center;justify-content:center;background:hsl(228 20% 10%)">
+    <div id="preloader" style="position:fixed;inset:0;z-index:9999;display:flex;align-items:center;justify-content:center;background:hsl(0 0% 10%)">
       <div style="display:flex;flex-direction:column;align-items:center;gap:24px">
-        <div data-logo style="width:48px;height:48px;background:hsl(258 70% 60%);-webkit-mask:url(/logo.svg) center/contain no-repeat;mask:url(/logo.svg) center/contain no-repeat"></div>
-        <div data-spinner style="width:24px;height:24px;border:2.5px solid hsl(258 70% 60% / 0.25);border-top-color:hsl(258 70% 60%);border-radius:50%;animation:ditto-spin .7s linear infinite"></div>
+        <div data-logo style="width:48px;height:48px;background:hsl(14 79% 58%);-webkit-mask:url(/logo.svg) center/contain no-repeat;mask:url(/logo.svg) center/contain no-repeat"></div>
+        <div data-spinner style="width:24px;height:24px;border:2.5px solid hsl(14 79% 58% / 0.25);border-top-color:hsl(14 79% 58%);border-radius:50%;animation:agora-spin .7s linear infinite"></div>
       </div>
     </div>
     <!-- Blocking script: reads theme from localStorage and applies it

ios/App/App.xcodeproj/project.pbxproj

@@ -15,7 +15,6 @@
 		504EC30F1FED79650016851F /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 504EC30E1FED79650016851F /* Assets.xcassets */; };
 		504EC3121FED79650016851F /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 504EC3101FED79650016851F /* LaunchScreen.storyboard */; };
 		50B271D11FEDC1A000F3C39B /* public in Resources */ = {isa = PBXBuildFile; fileRef = 50B271D01FEDC1A000F3C39B /* public */; };
-		B1A2C3D40001000100000001 /* SandboxPlugin.swift in Sources */ = {isa = PBXBuildFile; fileRef = B1A2C3D40001000100000002 /* SandboxPlugin.swift */; };
 		B1A2C3D40002000100000001 /* DittoBridgeViewController.swift in Sources */ = {isa = PBXBuildFile; fileRef = B1A2C3D40002000100000002 /* DittoBridgeViewController.swift */; };
 		B1A2C3D40005000100000001 /* PrivacyInfo.xcprivacy in Resources */ = {isa = PBXBuildFile; fileRef = B1A2C3D40005000100000002 /* PrivacyInfo.xcprivacy */; };
 		B1A2C3D40006000100000001 /* DittoNotificationPlugin.swift in Sources */ = {isa = PBXBuildFile; fileRef = B1A2C3D40006000100000002 /* DittoNotificationPlugin.swift */; };
@@ -33,7 +32,6 @@
 		504EC3131FED79650016851F /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
 		50B271D01FEDC1A000F3C39B /* public */ = {isa = PBXFileReference; lastKnownFileType = folder; path = public; sourceTree = "<group>"; };
 		958DCC722DB07C7200EA8C5F /* debug.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = debug.xcconfig; path = ../debug.xcconfig; sourceTree = SOURCE_ROOT; };
-		B1A2C3D40001000100000002 /* SandboxPlugin.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = SandboxPlugin.swift; sourceTree = "<group>"; };
 		B1A2C3D40002000100000002 /* DittoBridgeViewController.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DittoBridgeViewController.swift; sourceTree = "<group>"; };
 		B1A2C3D40004000100000002 /* App.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; path = App.entitlements; sourceTree = "<group>"; };
 		B1A2C3D40005000100000002 /* PrivacyInfo.xcprivacy */ = {isa = PBXFileReference; lastKnownFileType = text.xml; path = PrivacyInfo.xcprivacy; sourceTree = "<group>"; };
@@ -76,7 +74,6 @@
 				50379B222058CBB4000EE86E /* capacitor.config.json */,
 				B1A2C3D40004000100000002 /* App.entitlements */,
 				504EC3071FED79650016851F /* AppDelegate.swift */,
-				B1A2C3D40001000100000002 /* SandboxPlugin.swift */,
 				B1A2C3D40002000100000002 /* DittoBridgeViewController.swift */,
 				B1A2C3D40006000100000002 /* DittoNotificationPlugin.swift */,
 				B1A2C3D40007000100000002 /* NostrPoller.swift */,
@@ -174,7 +171,6 @@
 			buildActionMask = 2147483647;
 			files = (
 				504EC3081FED79650016851F /* AppDelegate.swift in Sources */,
-				B1A2C3D40001000100000001 /* SandboxPlugin.swift in Sources */,
 				B1A2C3D40002000100000001 /* DittoBridgeViewController.swift in Sources */,
 				B1A2C3D40006000100000001 /* DittoNotificationPlugin.swift in Sources */,
 				B1A2C3D40007000100000001 /* NostrPoller.swift in Sources */,
@@ -327,9 +323,9 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 2.7.0;
+				MARKETING_VERSION = 2.14.4;
 				OTHER_SWIFT_FLAGS = "$(inherited) \"-D\" \"COCOAPODS\" \"-DDEBUG\"";
-				PRODUCT_BUNDLE_IDENTIFIER = pub.ditto.app;
+				PRODUCT_BUNDLE_IDENTIFIER = pub.agora.app;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG;
 				SWIFT_VERSION = 5.0;
@@ -351,8 +347,8 @@
 					"$(inherited)",
 					"@executable_path/Frameworks",
 				);
-				MARKETING_VERSION = 2.7.0;
-				PRODUCT_BUNDLE_IDENTIFIER = pub.ditto.app;
+				MARKETING_VERSION = 2.8.0;
+				PRODUCT_BUNDLE_IDENTIFIER = pub.agora.app;
 				PRODUCT_NAME = "$(TARGET_NAME)";
 				SWIFT_ACTIVE_COMPILATION_CONDITIONS = "";
 				SWIFT_VERSION = 5.0;

ios/App/App/App.entitlements

@@ -4,8 +4,8 @@
 <dict>
 	<key>com.apple.developer.associated-domains</key>
 	<array>
-		<string>webcredentials:ditto.pub</string>
-		<string>webcredentials:ditto.pub?mode=developer</string>
+		<string>webcredentials:agora.spot</string>
+		<string>webcredentials:agora.spot?mode=developer</string>
 	</array>
 </dict>
 </plist>

ios/App/App/Info.plist

@@ -7,7 +7,7 @@
 	<key>CFBundleDevelopmentRegion</key>
 	<string>en</string>
 	<key>CFBundleDisplayName</key>
-        <string>Ditto</string>
+        <string>Agora</string>
 	<key>CFBundleExecutable</key>
 	<string>$(EXECUTABLE_NAME)</string>
 	<key>CFBundleIdentifier</key>
@@ -48,11 +48,11 @@
 	<key>UIViewControllerBasedStatusBarAppearance</key>
 	<true/>
 	<key>NSPhotoLibraryUsageDescription</key>
-	<string>Ditto needs access to your photo library to upload images to your posts and profile.</string>
+	<string>Agora needs access to your photo library to upload images to your posts and profile.</string>
 	<key>NSCameraUsageDescription</key>
-	<string>Ditto needs camera access to take photos and videos for your posts.</string>
+	<string>Agora needs camera access to take photos and videos for your posts.</string>
 	<key>NSMicrophoneUsageDescription</key>
-	<string>Ditto needs access to your microphone to record voice messages.</string>
+	<string>Agora needs access to your microphone to record voice messages.</string>
 	<key>ITSAppUsesNonExemptEncryption</key>
 	<false/>
 	<key>UIBackgroundModes</key>
@@ -61,7 +61,7 @@
 	</array>
 	<key>BGTaskSchedulerPermittedIdentifiers</key>
 	<array>
-		<string>pub.ditto.app.notification-refresh</string>
+		<string>pub.agora.app.notification-refresh</string>
 	</array>
 </dict>
 </plist>

ios/App/App/SandboxPlugin.swift

@@ -1,541 +0,0 @@
-import Foundation
-import Capacitor
-import WebKit
-
-// MARK: - Plugin
-
-/// Capacitor plugin that creates isolated WKWebViews for sandboxed content.
-///
-/// Each sandbox gets a unique custom URL scheme (`sbx-<id>://`) so that
-/// every embedded app has its own origin (separate localStorage, cookies, etc.).
-/// All requests on the custom scheme are intercepted via `WKURLSchemeHandler`
-/// and forwarded to the JS layer as fetch events — the same protocol
-/// iframe.diy uses. This lets the existing React code serve files identically.
-@objc(SandboxPlugin)
-public class SandboxPlugin: CAPPlugin, CAPBridgedPlugin {
-    public let identifier = "SandboxPlugin"
-    public let jsName = "SandboxPlugin"
-    public let pluginMethods: [CAPPluginMethod] = [
-        CAPPluginMethod(name: "create", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "navigate", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "updateFrame", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "respondToFetch", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "postMessage", returnType: CAPPluginReturnPromise),
-        CAPPluginMethod(name: "destroy", returnType: CAPPluginReturnPromise),
-    ]
-
-    /// Active sandbox instances, keyed by sandbox ID.
-    private var sandboxes: [String: SandboxInstance] = [:]
-
-    // MARK: - Plugin Methods
-
-    @objc func create(_ call: CAPPluginCall) {
-        guard let sandboxId = call.getString("id") else {
-            call.reject("Missing required parameter: id")
-            return
-        }
-        guard let frame = call.getObject("frame"),
-              let x = frame["x"] as? Double,
-              let y = frame["y"] as? Double,
-              let width = frame["width"] as? Double,
-              let height = frame["height"] as? Double else {
-            call.reject("Missing or invalid parameter: frame")
-            return
-        }
-
-        if sandboxes[sandboxId] != nil {
-            call.reject("Sandbox already exists: \(sandboxId)")
-            return
-        }
-
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-
-            let webViewFrame = CGRect(x: x, y: y, width: width, height: height)
-            let sandbox = SandboxInstance(
-                id: sandboxId,
-                frame: webViewFrame,
-                plugin: self
-            )
-            self.sandboxes[sandboxId] = sandbox
-
-            // Add the container (WebView + spinner overlay) on top of
-            // the Capacitor WebView.
-            if let bridge = self.bridge,
-               let webView = bridge.webView {
-                webView.superview?.addSubview(sandbox.containerView)
-            }
-
-            call.resolve()
-        }
-    }
-
-    @objc func navigate(_ call: CAPPluginCall) {
-        guard let sandboxId = call.getString("id") else {
-            call.reject("Missing required parameter: id")
-            return
-        }
-
-        DispatchQueue.main.async { [weak self] in
-            guard let sandbox = self?.sandboxes[sandboxId] else {
-                call.reject("Sandbox not found: \(sandboxId)")
-                return
-            }
-            sandbox.navigateToApp()
-            call.resolve()
-        }
-    }
-
-    @objc func updateFrame(_ call: CAPPluginCall) {
-        guard let sandboxId = call.getString("id") else {
-            call.reject("Missing required parameter: id")
-            return
-        }
-        guard let frame = call.getObject("frame"),
-              let x = frame["x"] as? Double,
-              let y = frame["y"] as? Double,
-              let width = frame["width"] as? Double,
-              let height = frame["height"] as? Double else {
-            call.reject("Missing or invalid parameter: frame")
-            return
-        }
-
-        DispatchQueue.main.async { [weak self] in
-            guard let sandbox = self?.sandboxes[sandboxId] else {
-                call.reject("Sandbox not found: \(sandboxId)")
-                return
-            }
-            sandbox.containerView.frame = CGRect(x: x, y: y, width: width, height: height)
-            call.resolve()
-        }
-    }
-
-    @objc func respondToFetch(_ call: CAPPluginCall) {
-        guard let sandboxId = call.getString("id") else {
-            call.reject("Missing required parameter: id")
-            return
-        }
-        guard let requestId = call.getString("requestId") else {
-            call.reject("Missing required parameter: requestId")
-            return
-        }
-        guard let response = call.getObject("response") else {
-            call.reject("Missing required parameter: response")
-            return
-        }
-
-        guard let sandbox = sandboxes[sandboxId] else {
-            call.reject("Sandbox not found: \(sandboxId)")
-            return
-        }
-
-        sandbox.schemeHandler.resolveRequest(
-            requestId: requestId,
-            status: response["status"] as? Int ?? 200,
-            statusText: response["statusText"] as? String ?? "OK",
-            headers: response["headers"] as? [String: String] ?? [:],
-            bodyBase64: response["body"] as? String
-        )
-
-        call.resolve()
-    }
-
-    @objc func postMessage(_ call: CAPPluginCall) {
-        guard let sandboxId = call.getString("id") else {
-            call.reject("Missing required parameter: id")
-            return
-        }
-        guard let message = call.getObject("message") else {
-            call.reject("Missing required parameter: message")
-            return
-        }
-
-        guard let sandbox = sandboxes[sandboxId] else {
-            call.reject("Sandbox not found: \(sandboxId)")
-            return
-        }
-
-        DispatchQueue.main.async {
-            sandbox.postMessageToWebView(message)
-        }
-
-        call.resolve()
-    }
-
-    @objc func destroy(_ call: CAPPluginCall) {
-        guard let sandboxId = call.getString("id") else {
-            call.reject("Missing required parameter: id")
-            return
-        }
-
-        DispatchQueue.main.async { [weak self] in
-            guard let self = self else { return }
-            if let sandbox = self.sandboxes.removeValue(forKey: sandboxId) {
-                sandbox.containerView.removeFromSuperview()
-                sandbox.schemeHandler.cancelAll()
-            }
-            call.resolve()
-        }
-    }
-
-    // MARK: - Event Forwarding
-
-    /// Forward a fetch request from the native WebView to JS.
-    func emitFetchRequest(sandboxId: String, requestId: String, request: [String: Any]) {
-        notifyListeners("fetch", data: [
-            "id": sandboxId,
-            "requestId": requestId,
-            "request": request,
-        ])
-    }
-
-    /// Forward a script message from the sandbox to JS.
-    func emitScriptMessage(sandboxId: String, message: [String: Any]) {
-        notifyListeners("scriptMessage", data: [
-            "id": sandboxId,
-            "message": message,
-        ])
-    }
-}
-
-// MARK: - SandboxInstance
-
-/// Manages a single sandboxed WKWebView instance.
-private class SandboxInstance: NSObject, WKScriptMessageHandler, WKNavigationDelegate {
-    let id: String
-    let webView: WKWebView
-    let schemeHandler: SandboxSchemeHandler
-    private weak var plugin: SandboxPlugin?
-    private let customScheme: String
-
-    /// Container view that holds the WebView and spinner overlay.
-    let containerView: UIView
-
-    /// Native spinner overlay, removed when the first page finishes loading.
-    private var spinnerOverlay: UIView?
-
-    init(id: String, frame: CGRect, plugin: SandboxPlugin) {
-        self.id = id
-        self.plugin = plugin
-
-        // Each sandbox gets a unique custom URL scheme so that WKWebView
-        // assigns a distinct origin, isolating localStorage/IndexedDB/cookies.
-        self.customScheme = "sbx-\(id)"
-
-        self.schemeHandler = SandboxSchemeHandler(
-            sandboxId: id,
-            scheme: self.customScheme,
-            plugin: plugin
-        )
-
-        let config = WKWebViewConfiguration()
-        config.setURLSchemeHandler(self.schemeHandler, forURLScheme: self.customScheme)
-
-        // Add a script message handler for communication from injected scripts.
-        let userContentController = WKUserContentController()
-
-        // Inject a bridge script that:
-        // 1. Provides window.parent.postMessage()-like functionality
-        // 2. Routes messages through the native bridge
-        let bridgeScript = WKUserScript(
-            source: SandboxInstance.bridgeScript(scheme: self.customScheme),
-            injectionTime: .atDocumentStart,
-            forMainFrameOnly: false
-        )
-        userContentController.addUserScript(bridgeScript)
-
-        config.userContentController = userContentController
-        config.preferences.javaScriptCanOpenWindowsAutomatically = false
-        config.defaultWebpagePreferences.allowsContentJavaScript = true
-
-        // Container view that holds the WebView + spinner overlay.
-        self.containerView = UIView(frame: frame)
-
-        self.webView = WKWebView(frame: containerView.bounds, configuration: config)
-        self.webView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
-        self.webView.isOpaque = false
-        self.webView.backgroundColor = UIColor(red: 0x14/255.0, green: 0x16/255.0, blue: 0x1f/255.0, alpha: 1)
-        self.webView.scrollView.backgroundColor = self.webView.backgroundColor
-        self.webView.scrollView.bounces = false
-        self.containerView.addSubview(self.webView)
-
-        // Dark overlay behind the spinner.
-        let overlay = UIView(frame: containerView.bounds)
-        overlay.autoresizingMask = [.flexibleWidth, .flexibleHeight]
-        overlay.backgroundColor = UIColor(red: 0x14/255.0, green: 0x16/255.0, blue: 0x1f/255.0, alpha: 1)
-        self.containerView.addSubview(overlay)
-
-        // Native spinner — uses UIActivityIndicatorView which animates on
-        // the render thread independently of JS/main-thread work.
-        let spinner = UIActivityIndicatorView(style: .medium)
-        spinner.color = UIColor(red: 124/255.0, green: 92/255.0, blue: 220/255.0, alpha: 1)
-        spinner.translatesAutoresizingMaskIntoConstraints = false
-        spinner.startAnimating()
-        overlay.addSubview(spinner)
-        NSLayoutConstraint.activate([
-            spinner.centerXAnchor.constraint(equalTo: overlay.centerXAnchor),
-            spinner.centerYAnchor.constraint(equalTo: overlay.centerYAnchor),
-        ])
-
-        self.spinnerOverlay = overlay
-
-        super.init()
-
-        // Register the message handler and navigation delegate after super.init().
-        userContentController.add(self, name: "sandboxBridge")
-        self.webView.navigationDelegate = self
-    }
-
-    /// Navigate the WebView to the sandbox's entry point.
-    func navigateToApp() {
-        let initialURL = URL(string: "\(customScheme)://app/index.html")!
-        webView.load(URLRequest(url: initialURL))
-    }
-
-    /// Remove the native loading overlay. Safe to call multiple times.
-    func hideSpinner() {
-        spinnerOverlay?.removeFromSuperview()
-        spinnerOverlay = nil
-    }
-
-    /// Post a JSON-RPC message to injected scripts inside the WebView.
-    func postMessageToWebView(_ message: [String: Any]) {
-        guard let jsonData = try? JSONSerialization.data(withJSONObject: message),
-              let jsonString = String(data: jsonData, encoding: .utf8) else {
-            return
-        }
-
-        let js = """
-        (function() {
-            if (window.__sandboxBridge && window.__sandboxBridge.onMessage) {
-                window.__sandboxBridge.onMessage(\(jsonString));
-            }
-        })();
-        """
-        webView.evaluateJavaScript(js, completionHandler: nil)
-    }
-
-    // MARK: - WKScriptMessageHandler
-
-    /// Receive messages from injected scripts via webkit.messageHandlers.sandboxBridge.
-    func userContentController(
-        _ userContentController: WKUserContentController,
-        didReceive message: WKScriptMessage
-    ) {
-        guard message.name == "sandboxBridge",
-              let body = message.body as? [String: Any] else {
-            return
-        }
-        plugin?.emitScriptMessage(sandboxId: id, message: body)
-    }
-
-    // MARK: - WKNavigationDelegate
-
-    /// Remove the spinner overlay once the first page finishes loading.
-    func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
-        hideSpinner()
-    }
-
-    // MARK: - Bridge Script
-
-    /// JavaScript injected at document start that provides:
-    ///   - `window.parent.postMessage()` emulation via WKScriptMessageHandler
-    ///   - `window.__sandboxBridge.onMessage()` for receiving messages from parent
-    ///   - `window.addEventListener("message", ...)` support for injected scripts
-    private static func bridgeScript(scheme: String) -> String {
-        return """
-        (function() {
-            'use strict';
-
-            // Message listeners registered by injected scripts.
-            var messageListeners = [];
-
-            // Bridge object for native communication.
-            window.__sandboxBridge = {
-                onMessage: function(data) {
-                    // Dispatch to all registered message listeners.
-                    var event = {
-                        data: data,
-                        origin: '\(scheme)://app',
-                        source: window.parent,
-                        type: 'message'
-                    };
-                    for (var i = 0; i < messageListeners.length; i++) {
-                        try {
-                            messageListeners[i](event);
-                        } catch (e) {
-                            console.error('[SandboxBridge] Listener error:', e);
-                        }
-                    }
-                }
-            };
-
-            // Override addEventListener to capture "message" listeners.
-            var originalAddEventListener = window.addEventListener;
-            window.addEventListener = function(type, listener, options) {
-                if (type === 'message' && typeof listener === 'function') {
-                    messageListeners.push(listener);
-                }
-                return originalAddEventListener.call(window, type, listener, options);
-            };
-
-            var originalRemoveEventListener = window.removeEventListener;
-            window.removeEventListener = function(type, listener, options) {
-                if (type === 'message') {
-                    var idx = messageListeners.indexOf(listener);
-                    if (idx !== -1) messageListeners.splice(idx, 1);
-                }
-                return originalRemoveEventListener.call(window, type, listener, options);
-            };
-
-            // Emulate window.parent.postMessage for scripts that use it
-            // (e.g. the webxdc bridge script, preview injected script).
-            if (!window.parent || window.parent === window) {
-                window.parent = {};
-            }
-            window.parent.postMessage = function(data, targetOrigin, transfer) {
-                if (data && typeof data === 'object' && data.jsonrpc === '2.0') {
-                    try {
-                        window.webkit.messageHandlers.sandboxBridge.postMessage(data);
-                    } catch (e) {
-                        console.error('[SandboxBridge] postMessage failed:', e);
-                    }
-                }
-            };
-        })();
-        """;
-    }
-}
-
-// MARK: - SandboxSchemeHandler
-
-/// WKURLSchemeHandler that intercepts all requests on the sandbox's custom
-/// URL scheme and forwards them to the JS layer as fetch events.
-private class SandboxSchemeHandler: NSObject, WKURLSchemeHandler {
-    private let sandboxId: String
-    private let scheme: String
-    private weak var plugin: SandboxPlugin?
-
-    /// Pending scheme tasks waiting for a response from JS.
-    /// Key: requestId (UUID string), Value: the WKURLSchemeTask to respond to.
-    private var pendingTasks: [String: WKURLSchemeTask] = [:]
-    private let lock = NSLock()
-
-    init(sandboxId: String, scheme: String, plugin: SandboxPlugin) {
-        self.sandboxId = sandboxId
-        self.scheme = scheme
-        self.plugin = plugin
-    }
-
-    func webView(_ webView: WKWebView, start urlSchemeTask: WKURLSchemeTask) {
-        let request = urlSchemeTask.request
-        guard let url = request.url else {
-            urlSchemeTask.didFailWithError(NSError(
-                domain: "SandboxPlugin", code: -1,
-                userInfo: [NSLocalizedDescriptionKey: "No URL in request"]
-            ))
-            return
-        }
-
-        let requestId = UUID().uuidString
-
-        lock.lock()
-        pendingTasks[requestId] = urlSchemeTask
-        lock.unlock()
-
-        // Serialise the request for the fetch event.
-        // Rewrite the URL so it looks like a normal HTTP URL to the parent
-        // (e.g. "sbx-abc123://app/index.html" -> "https://<sandboxId>.sandbox.native/index.html")
-        // The JS side only cares about the pathname.
-        var headers: [String: String] = [:]
-        if let allHeaders = request.allHTTPHeaderFields {
-            headers = allHeaders
-        }
-
-        var bodyBase64: String? = nil
-        if let bodyData = request.httpBody {
-            bodyBase64 = bodyData.base64EncodedString()
-        }
-
-        let path = url.path.isEmpty ? "/" : url.path
-        let rewrittenURL = "https://\(sandboxId).sandbox.native\(path)"
-
-        let serialisedRequest: [String: Any] = [
-            "url": rewrittenURL,
-            "method": request.httpMethod ?? "GET",
-            "headers": headers,
-            "body": bodyBase64 as Any,
-        ]
-
-        plugin?.emitFetchRequest(
-            sandboxId: sandboxId,
-            requestId: requestId,
-            request: serialisedRequest
-        )
-    }
-
-    func webView(_ webView: WKWebView, stop urlSchemeTask: WKURLSchemeTask) {
-        // Remove the task from pending — JS response will be ignored if it arrives later.
-        lock.lock()
-        let removed = pendingTasks.first(where: { $0.value === urlSchemeTask })
-        if let key = removed?.key {
-            pendingTasks.removeValue(forKey: key)
-        }
-        lock.unlock()
-    }
-
-    /// Called by the plugin when JS responds to a fetch request.
-    func resolveRequest(
-        requestId: String,
-        status: Int,
-        statusText: String,
-        headers: [String: String],
-        bodyBase64: String?
-    ) {
-        lock.lock()
-        guard let task = pendingTasks.removeValue(forKey: requestId) else {
-            lock.unlock()
-            return
-        }
-        lock.unlock()
-
-        // Decode the base64 body.
-        var bodyData: Data? = nil
-        if let b64 = bodyBase64 {
-            bodyData = Data(base64Encoded: b64)
-        }
-
-        // Build the response.
-        // Use the task's original URL for the response.
-        let responseURL = task.request.url ?? URL(string: "\(scheme)://app/")!
-        let response = HTTPURLResponse(
-            url: responseURL,
-            statusCode: status,
-            httpVersion: "HTTP/1.1",
-            headerFields: headers
-        )!
-
-        DispatchQueue.main.async {
-            task.didReceive(response)
-            if let data = bodyData {
-                task.didReceive(data)
-            }
-            task.didFinish()
-        }
-    }
-
-    /// Cancel all pending tasks (called on destroy).
-    func cancelAll() {
-        lock.lock()
-        let tasks = pendingTasks
-        pendingTasks.removeAll()
-        lock.unlock()
-
-        for (_, task) in tasks {
-            task.didFailWithError(NSError(
-                domain: "SandboxPlugin", code: -999,
-                userInfo: [NSLocalizedDescriptionKey: "Sandbox destroyed"]
-            ))
-        }
-    }
-}

ios/fastlane/Appfile

@@ -0,0 +1,2 @@
+app_identifier("pub.ditto.app")
+team_id("GZLTTH5DLM")

ios/fastlane/Fastfile

@@ -0,0 +1,146 @@
+default_platform(:ios)
+
+platform :ios do
+  # ─── Lanes ────────────────────────────────────────────────────────────
+
+  desc "Build and sign the App Store IPA. Output at ../artifacts/Ditto.ipa."
+  lane :build_ipa do
+    setup_lane_signing!
+    build_release_ipa!
+  end
+
+  desc "Submit an already-built IPA to App Store Connect for review. " \
+       "Set IPA_PATH to the IPA's location."
+  lane :submit_release do
+    ipa_path = ENV.fetch("IPA_PATH") do
+      UI.user_error!("submit_release requires the IPA_PATH env var")
+    end
+    UI.user_error!("IPA not found at #{ipa_path}") unless File.exist?(ipa_path)
+    submit_release_for_review!(ipa_path)
+  end
+
+  desc "Build, sign, and submit Ditto to the App Store for review (single-step convenience)."
+  lane :release do
+    setup_lane_signing!
+    build_release_ipa!
+    # Use the IPA path set by build_app rather than recomputing it from
+    # __dir__, which gets fragile across fastlane-relative paths.
+    ipa_path = lane_context[SharedValues::IPA_OUTPUT_PATH]
+    UI.user_error!("build_app did not set IPA_OUTPUT_PATH") unless ipa_path
+    submit_release_for_review!(ipa_path)
+  end
+
+  desc "Submit an already-uploaded build for review (skip build/upload). " \
+       "Use BUILD_NUMBER and VERSION env vars."
+  lane :submit_only do
+    submit_release_for_review!(nil)
+  end
+
+  # ─── Helpers ──────────────────────────────────────────────────────────
+
+  def setup_lane_signing!
+    # Create an ephemeral keychain so we never touch the login keychain.
+    setup_ci
+
+    api_key = build_api_key!
+
+    # Fetch encrypted distribution cert + provisioning profile from the
+    # shared certificates repo. --readonly: never mutate from CI.
+    # Passing api_key makes match contact Apple's portal to verify the
+    # cert is still valid for the team — fails fast on revoked/expired
+    # certs instead of letting xcodebuild stumble later.
+    match(type: "appstore", readonly: true, api_key: api_key)
+
+    api_key
+  end
+
+  def build_api_key!
+    # Build the API key hash inline. We avoid the app_store_connect_api_key
+    # action because it sets APP_STORE_CONNECT_API_KEY_PATH (path to the .p8)
+    # which collides with match's APP_STORE_CONNECT_API_KEY_PATH (path to a
+    # JSON descriptor). Same env name, different formats.
+    @api_key ||= {
+      key_id: ENV.fetch("APP_STORE_CONNECT_API_KEY_ID"),
+      issuer_id: ENV.fetch("APP_STORE_CONNECT_API_KEY_ISSUER_ID"),
+      key: File.binread(ENV.fetch("ASC_KEY_PATH")),
+      duration: 1200,
+      in_house: false,
+    }
+  end
+
+  def build_release_ipa!
+    # Stamp build number from CI pipeline ID so every release is monotonically increasing.
+    increment_build_number(
+      xcodeproj: "App/App.xcodeproj",
+      build_number: ENV.fetch("CI_PIPELINE_IID"),
+    )
+
+    # Marketing version is set externally (sed in CI) before this lane runs.
+
+    build_app(
+      project: "App/App.xcodeproj",
+      scheme: "App",
+      configuration: "Release",
+      export_method: "app-store",
+      output_directory: "../artifacts",
+      output_name: "Ditto.ipa",
+      clean: true,
+      # Override the Xcode project's Automatic signing for this build only.
+      # Match has already installed the AppStore cert + profile into the
+      # ephemeral keychain; tell xcodebuild to use them explicitly so it
+      # doesn't also try to find an iOS Development cert (which we never
+      # provision in CI).
+      xcargs: [
+        "CODE_SIGN_STYLE=Manual",
+        "CODE_SIGN_IDENTITY='Apple Distribution'",
+        "PROVISIONING_PROFILE_SPECIFIER='match AppStore pub.ditto.app'",
+        "DEVELOPMENT_TEAM=GZLTTH5DLM",
+      ].join(" "),
+      export_options: {
+        method: "app-store",
+        signingStyle: "manual",
+        teamID: "GZLTTH5DLM",
+        provisioningProfiles: {
+          "pub.ditto.app" => "match AppStore pub.ditto.app",
+        },
+      },
+    )
+  end
+
+  # If ipa_path is nil, deliver picks up the latest processed build for the
+  # configured app version (used by the submit_only lane).
+  def submit_release_for_review!(ipa_path)
+    api_key = build_api_key!
+
+    options = {
+      api_key: api_key,
+      submit_for_review: true,
+      automatic_release: false,
+      force: true,
+      precheck_include_in_app_purchases: false,
+      # Don't try to PATCH content rights on every submit — Apple's API
+      # rejects updates to contentRightsDeclaration once the listing has
+      # an established state. The values stay as set in the App Store
+      # Connect UI / from a prior submission.
+      submission_information: {
+        export_compliance_uses_encryption: false,
+      },
+      skip_screenshots: true,
+      # Keep skip_app_version_update=false: deliver needs to PATCH the
+      # version's whatsNew (release notes) and platform-version metadata
+      # before submit_for_review will accept the version.
+      skip_app_version_update: false,
+      skip_metadata: false,
+      metadata_path: "./fastlane/metadata",
+      run_precheck_before_submit: false,
+    }
+    options[:ipa] = ipa_path if ipa_path
+    if ENV["BUILD_NUMBER"]
+      options[:build_number] = ENV["BUILD_NUMBER"]
+      options[:skip_binary_upload] = true
+    end
+    options[:app_version] = ENV["VERSION"] if ENV["VERSION"]
+
+    deliver(**options)
+  end
+end

ios/fastlane/Matchfile

@@ -0,0 +1,5 @@
+git_url("https://gitlab.com/soapbox-pub/certificates.git")
+storage_mode("git")
+type("appstore")
+app_identifier(["pub.ditto.app"])
+team_id("GZLTTH5DLM")

ios/fastlane/metadata/en-US/release_notes.txt

@@ -0,0 +1 @@
+Placeholder. CI overwrites this file with the release summary paragraph from CHANGELOG.md (the leading plaintext paragraph in the section for the current version).

nginx.conf

@@ -0,0 +1,30 @@
+server {
+    listen 80;
+    server_name _;
+    root /usr/share/nginx/html;
+    index index.html;
+
+    gzip on;
+    gzip_vary on;
+    gzip_min_length 1024;
+    gzip_types text/plain text/css text/xml text/javascript application/x-javascript application/xml+rss application/javascript application/json;
+
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header X-XSS-Protection "1; mode=block" always;
+
+    location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
+        expires 1y;
+        add_header Cache-Control "public, immutable";
+    }
+
+    location /health {
+        access_log off;
+        return 200 "healthy\n";
+        add_header Content-Type text/plain;
+    }
+
+    location / {
+        try_files $uri $uri/ /index.html;
+    }
+}

nginx.dev.conf

@@ -0,0 +1,35 @@
+server {
+    listen 80;
+    server_name _;
+    root /usr/share/nginx/html;
+    index index.html;
+
+    gzip on;
+    gzip_vary on;
+    gzip_min_length 1024;
+    gzip_types text/plain text/css text/xml text/javascript application/x-javascript application/xml+rss application/javascript application/json;
+
+    add_header X-Frame-Options "SAMEORIGIN" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header X-XSS-Protection "1; mode=block" always;
+
+    location /health {
+        access_log off;
+        return 200 "healthy\n";
+        add_header Content-Type text/plain;
+    }
+
+    location / {
+        resolver 127.0.0.11 valid=10s;
+        set $vite_backend http://vite:8080;
+        proxy_pass $vite_backend;
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        proxy_read_timeout 86400;
+    }
+}

package.json

@@ -1,12 +1,12 @@
 {
-  "name": "ditto",
+  "name": "agora",
   "private": true,
-  "version": "2.7.0",
+  "version": "2.8.0",
   "type": "module",
   "scripts": {
     "dev": "npm i --silent && vite",
     "build": "npm i --silent && vite build -l error && cp dist/index.html dist/404.html && echo 'Project built successfully!'",
-    "test": "npm i --silent && tsc --noEmit && eslint && vitest run --reporter=dot --silent && vite build -l error && cp dist/index.html dist/404.html && echo 'All tests passed!'",
+    "test": "npm i --silent && tsc --noEmit && eslint --cache && vitest run --reporter=dot --silent && vite build -l error && cp dist/index.html dist/404.html && echo 'All tests passed!'",
     "cap:sync": "npx cap sync && node scripts/patch-cap-config.mjs",
     "keygen": "keytool -genkey -v -keystore android/app/my-upload-key.keystore -keyalg RSA -keysize 2048 -validity 10000 -alias upload",
     "icons": "bash scripts/generate-icons.sh"
@@ -15,7 +15,9 @@
     "node": ">=22"
   },
   "dependencies": {
+    "@breeztech/breez-sdk-spark": "^0.13.2-dev1",
     "@capacitor/app": "^8.0.0",
+    "@capacitor/barcode-scanner": "^3.0.2",
     "@capacitor/core": "^8.1.0",
     "@capacitor/filesystem": "^8.1.2",
     "@capacitor/haptics": "^8.0.2",
@@ -67,9 +69,11 @@
     "@milkdown/prose": "^7.20.0",
     "@milkdown/react": "^7.20.0",
     "@milkdown/utils": "^7.20.0",
-    "@nostrify/nostrify": "^0.51.1",
-    "@nostrify/react": "^0.5.1",
-    "@nostrify/types": "^0.36.9",
+    "@noble/curves": "^2.2.0",
+    "@noble/hashes": "^1.8.0",
+    "@nostrify/nostrify": "^0.52.0",
+    "@nostrify/react": "^0.6.0",
+    "@nostrify/types": "^0.37.0",
     "@plausible-analytics/tracker": "^0.4.4",
     "@radix-ui/react-accordion": "^1.2.0",
     "@radix-ui/react-alert-dialog": "^1.1.1",
@@ -98,6 +102,8 @@
     "@radix-ui/react-toggle": "^1.1.0",
     "@radix-ui/react-toggle-group": "^1.1.0",
     "@radix-ui/react-tooltip": "^1.2.8",
+    "@samthomson/nostr-messaging": "^0.17.1",
+    "@scure/bip39": "^1.6.0",
     "@sentry/react": "^10.42.0",
     "@tanstack/react-query": "^5.56.2",
     "@unhead/addons": "^2.1.13",
@@ -108,6 +114,8 @@
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.0.0",
+    "d3-celestial": "^0.7.35",
+    "d3-scale": "^4.0.2",
     "date-fns": "^3.6.0",
     "dompurify": "^3.3.3",
     "embla-carousel-react": "^8.3.0",
@@ -115,9 +123,14 @@
     "fflate": "^0.8.2",
     "hls.js": "^1.6.15",
     "html-to-image": "^1.11.13",
+    "i18next": "^26.0.5",
+    "i18next-browser-languagedetector": "^8.2.1",
     "idb": "^8.0.3",
     "input-otp": "^1.2.4",
+    "iso-3166": "^4.4.0",
+    "leaflet": "^1.9.4",
     "lucide-react": "^1.8.0",
+    "ngeohash": "^0.6.3",
     "nostr-tools": "^2.13.0",
     "qrcode": "^1.5.4",
     "react": "^19.2.4",
@@ -126,7 +139,9 @@
     "react-dom": "^19.2.4",
     "react-easy-crop": "^5.5.6",
     "react-hook-form": "^7.71.1",
+    "react-i18next": "^17.0.4",
     "react-intersection-observer": "^9.16.0",
+    "react-leaflet": "^4.2.1",
     "react-markdown": "^10.1.0",
     "react-resizable-panels": "^2.1.3",
     "react-router-dom": "^6.26.2",
@@ -151,7 +166,9 @@
     "@testing-library/dom": "^10.4.1",
     "@testing-library/jest-dom": "^6.6.3",
     "@testing-library/react": "^16.3.2",
+    "@types/d3-scale": "^4.0.9",
     "@types/dompurify": "^3.0.5",
+    "@types/leaflet": "^1.9.21",
     "@types/node": "^22.5.5",
     "@types/qrcode": "^1.5.5",
     "@types/react": "^19.2.14",

public/.well-known/apple-app-site-association

@@ -1,7 +1,7 @@
 {
   "webcredentials": {
     "apps": [
-      "GZLTTH5DLM.pub.ditto.app"
+      "GZLTTH5DLM.pub.agora.app"
     ]
   }
 }

public/.well-known/assetlinks.json

@@ -5,7 +5,7 @@
     ],
     "target": {
       "namespace": "android_app",
-      "package_name": "pub.ditto.app",
+      "package_name": "pub.agora.app",
       "sha256_cert_fingerprints": [
         "7C:05:A8:5A:07:0F:84:AE:43:DE:85:67:A4:5F:7F:FB:42:0A:05:05:27:CE:B6:8C:DA:AF:A5:E0:12:E0:9E:71",
         "E5:B1:A9:13:C9:37:35:3C:A5:E7:27:89:C0:9D:3D:0D:A5:4F:F5:26:88:06:BD:24:46:21:AB:61:6B:CC:C5:E5"

public/CHANGELOG.md

@@ -1,417 +1,7 @@
 # Changelog
 
-## [2.7.0] - 2026-04-14
+## [1.0.0] - 2026-04-30
 
 ### Added
-- Customizable widget sidebar -- drag, drop, and rearrange widgets on your feed including Trending, Hot Posts, Bluesky, AI Chat, Blobbi, Music, Photos, Wikipedia, and more
-- Blobbi rooms -- swipe between living spaces, clean up after your pet, and earn XP from daily care routines
-- Native push notifications on iOS with author names, content previews, and smart grouping by category
-- Haptic feedback throughout the app -- taps, buzzes, and pulses when you react, zap, repost, pull to refresh, play games, and interact with your Blobbi
-- Hot Posts widget showing the most popular posts from your feed at a glance
 
-### Changed
-- Sidebar widgets are now clickable links that take you to their full pages
-- Blobbi widget shows live stats with circular ring indicators and quick action buttons
-
-### Fixed
-- Zaps embedded in posts now render as proper inline cards instead of blank space
-- Quote posts display media and Blobbi companions correctly
-- Deep linking on Google Play works again
-- Game controller buttons no longer trigger text selection on long-press on iOS
-
-## [2.6.6] - 2026-04-12
-
-### Fixed
-- Emoji and mention autocomplete dropdowns no longer get clipped by the compose box
-- Emoji shortcodes now render as color emoji instead of plain text glyphs
-- Dialogs and input fields on Android are no longer obscured by the virtual keyboard
-- Signing requests on Android are more reliable and no longer silently fail after switching apps
-
-## [2.6.5] - 2026-04-11
-
-### Changed
-- Apps and games load significantly faster on Android with smarter prefetching and server affinity
-- Native loading spinners replace HTML-based ones on iOS and Android for a smoother experience
-
-### Fixed
-- External API requests on Android no longer fail due to hostname restrictions
-- iOS App Store compliance issues resolved
-
-## [2.6.4] - 2026-04-11
-
-### Added
-- iCloud Keychain integration on iOS -- your login credentials are now saved and restored automatically across devices
-
-### Changed
-- Empty feeds show a friendlier state with a discover button to help you find people to follow
-- Signup flow simplified -- cleaner profile step with a single Continue button
-
-### Fixed
-- Avatar fallback now shows the user's initial instead of a question mark
-- Android 16+ devices no longer have content hidden behind system bars
-- Signup dialog background clears properly when switching between light and dark themes
-- Sticky compose button stays anchored to the bottom even on empty feeds
-
-## [2.6.3] - 2026-04-10
-
-### Added
-- Lightning invoices embedded in posts now render as tappable payment cards
-- Blobbi companions in the feed reflect their current condition and projected health
-
-### Changed
-- Profile headers are cleaner -- lightning addresses and verification badges moved out of the way, and website URLs no longer show a trailing slash
-- Login credentials are saved to your browser's built-in password manager for easier sign-in across sessions
-- "Request to Vanish" renamed to "Delete Account" for clarity
-
-### Fixed
-- Badge image uploads now show a recommended 1:1 aspect ratio hint so your badges don't get cropped unexpectedly
-- Security hardening for URLs and styles sourced from the network
-
-## [2.6.2] - 2026-04-08
-
-### Added
-- Share follow packs and follow sets via link -- recipients see an immersive preview with member avatars, a "Follow All" button, and a combined feed from everyone in the pack
-- Curated home feed with a mix of photos, short videos, livestreams, and music -- content types are spaced out so your timeline stays fresh and varied
-- "Write a letter" option on profile menus for a more personal way to reach out
-- Push vs persistent notification delivery option on Android
-
-### Changed
-- Webxdc games and apps always open fullscreen for a more immersive experience
-- Login credentials are now stored in the device's secure keychain on iOS and Android instead of plain local storage
-- Profile fields now appear inline instead of in a separate right sidebar
-- Trending hashtags removed from the logged-out homepage for a cleaner first impression
-
-### Fixed
-- Webxdc and nsites work natively on iOS and Android without relying on browser sandboxing tricks
-- File downloads now save directly to Documents on iOS and Android instead of silently failing
-- Mobile search no longer scrolls the page behind it and properly hides the bottom navigation bar
-- iOS swipe-back navigation works correctly throughout the app
-- Blobbi companions appear reliably on profiles instead of sometimes going missing
-- IndexedDB no longer crashes on devices with Lockdown Mode enabled
-
-## [2.6.1] - 2026-04-06
-
-### Added
-- Manage your interest tabs (hashtags and locations) from the settings page
-- Edit button on custom profile tabs so you can tweak them without recreating from scratch
-- Follow packs and follow sets now show author info and action headers in the feed
-- Posts now show whether they were created or updated, so you can tell when something's been edited
-
-### Changed
-- Webxdc games and apps run in a more secure sandbox with stricter content policies and private subdomains
-- Nsite previews now use the same secure sandbox as webxdc apps
-- Blobbi items work as instant abilities instead of consumable inventory -- no more fiddly quantity pickers
-
-### Fixed
-- Desktop tab bar no longer overflows when you have lots of tabs -- scroll arrows appear automatically
-- Mobile compose box no longer randomly collapses or becomes unclickable
-- Profile avatar and banner lightbox no longer hides behind the right sidebar
-- Infinite scroll on custom profile tab feeds no longer reloads the same content
-- Reaction emoji are now visible on each row in the interactions modal
-- Missing bottom border on collapsed thread expand button restored
-
-## [2.6.0] - 2026-04-05
-
-### Added
-- Follow links and QR codes -- share a link or scannable code that lets anyone follow you with one tap, complete with your themed profile preview and recent posts
-- Immersive Blobbi hatching ceremony -- crack your egg through cinematic stages with shaking animations, a burst of light, sparkles, typewriter dialog, and a naming moment
-
-### Changed
-- Footer links redesigned as compact icon chips for a cleaner look
-- Custom emoji now render crisp at small sizes with pixel-perfect scaling
-
-### Fixed
-- Custom themes now apply correctly when logging in on a new device
-- Settings and preferences sync reliably across devices
-- Mobile sidebar links no longer clip into the safe area
-- Blobbi page background overlay now appears properly on custom themes
-- Blobbi companion state no longer resets unexpectedly from stale cache data
-- Letter compose picker no longer gets hidden behind the top navigation arc
-
-## [2.5.2] - 2026-04-04
-
-### Added
-- See who voted on each poll option -- tap the vote count to open a voters list with avatar stacks and per-option filter tabs
-- Poll votes now appear as activity cards in feeds and on detail pages
-
-### Fixed
-- Threads and replies load more reliably by following relay and author hints when fetching parent events
-
-## [2.5.1] - 2026-04-03
-
-### Fixed
-- Lightbox now reliably appears above all content, not just when opened from photo galleries
-
-## [2.5.0] - 2026-04-03
-
-### Added
-- Run nsites and web apps directly inside Ditto -- hit the "Run" button on any nsite or app card to preview it in an overlay without leaving your feed
-- File uploads in the poll composer -- attach images and media to your polls
-- Blobbi posts now appear in the homepage feed
-
-### Changed
-- Profile media sidebar fills remaining slots with photos from text posts when there aren't enough dedicated media posts
-- App cards now show banner images and improved layout
-
-### Fixed
-- Lightbox no longer appears behind the right sidebar
-- Compose box corners are properly rounded
-- Clicking buttons or links inside a post card no longer accidentally navigates to the post detail page
-
-## [2.4.1] - 2026-04-02
-
-### Added
-- Rich cards for Zapstore app releases and assets -- see download links, version info, platform badges, and hashes right in your feed
-
-### Fixed
-- First-hatch tour now shows for accounts that were onboarded before the tour existed, so no one misses the hatching moment
-
-## [2.4.0] - 2026-04-02
-
-### Added
-- First-hatch tour: a guided experience for hatching your very first Blobbi egg, with progressive crack animations, an inline card flow, and a reveal moment
-- Customizable bottom bar: rearrange or hide any item in the navigation bar to make Ditto feel like yours
-- Mission surface card in the feed that surfaces your active quests at a glance
-
-### Changed
-- Missions redesigned as a quest board with collapsible cards and a lighter aesthetic
-- "Edit Profile" mission now completes when you update any profile field, not just wall-specific edits
-- Media tab on profiles now shows only photos, videos, and other media -- not plain text posts
-- Blobbi onboarding state now syncs to your profile so it follows you across devices
-
-### Fixed
-- Notification dot no longer reappears after you've already marked notifications as read
-- Dialogs no longer fly up when the mobile keyboard opens
-
-## [2.3.1] - 2026-04-02
-
-### Changed
-- Drafts now save instantly to your device and sync to relays in the background, with a cloud sync indicator so you always know the status
-
-### Fixed
-- Dialogs stay visible above the keyboard on mobile instead of getting hidden behind it
-- Editing an existing article no longer incorrectly warns about a duplicate slug
-- Switching between rich text and markdown source mode no longer clears your content
-- Fix crash when editing in markdown source mode
-
-## [2.3.0] - 2026-04-02
-
-### Added
-- In-app article editor with a rich text toolbar, image uploads, auto-saving drafts, and a "My Articles" tab to manage drafts and published articles
-
-### Fixed
-- Custom emoji no longer stretch to fill their container
-- Mobile drawer now closes when tapping footer links like Changelog or Privacy
-- Logged-out users now default to the global tab on content feeds instead of seeing an empty follows tab
-
-## [2.2.11] - 2026-04-02
-
-### Fixed
-- Fix crash caused by the "What's new" toast firing outside the router
-
-## [2.2.10] - 2026-04-02
-
-### Added
-- App cards for Nostr apps now display in feeds and detail pages with hero images, icons, and quick-launch buttons
-- "What's new" toast appears after an app update with a changelog preview and link to the full changelog
-
-### Changed
-- Changelog page redesigned with a hero section for the latest release, collapsible older entries, and category icons inline with each item
-
-### Fixed
-- Compose box now fully resets to its collapsed state after posting, including poll options and media trays
-
-## [2.2.9] - 2026-04-01
-
-### Added
-- Emoji pack creator and editor with drag-and-drop image upload, auto-generated identifiers, and description field
-- Blobbi companions now appear in feeds and post detail pages
-
-### Changed
-- Blobbi shop redesigned with a tile layout and instant buy -- no more categories or accessory tabs
-- Emoji packs without any valid emojis are now hidden from feeds
-- Custom emoji shortcode collisions across packs are automatically resolved with pack-prefixed names
-
-## [2.2.8] - 2026-04-01
-
-### Added
-- Full threaded reply trees on post detail pages with collapsible deep branches and "Show X more replies" for sibling threads
-- Broadcast button in the Event JSON dialog to re-publish any event to your relays
-
-### Changed
-- My Badges tab overhauled with drag-and-drop reordering, a scrollable list, and a showcase-style carousel for pending badges
-- Encrypted letter envelopes now show the mailing side first (sender and recipient), then flip to reveal the wax seal
-- Blobbi companions are more expressive -- richer status reactions, sleeping visuals, and body effects like dirt and hunger cues
-
-### Fixed
-- Notification dot not clearing after marking notifications as read
-- Followers/following modal staying open after navigating to a profile
-
-## [2.2.7] - 2026-03-31
-
-### Fixed
-- Nushu script in encrypted letters now renders correctly on Android and iOS
-
-## [2.2.6] - 2026-03-31
-
-### Added
-- Encrypted letters now appear as interactive 3D envelopes with Nushu script -- flip and open them to reveal the secret writing inside
-- Zap receipts and profile metadata events now render in feeds and detail pages
-- Remote signer callback page for login flows with Amber, Primal, and other signing apps
-
-### Changed
-- Post action buttons extracted into a reusable PostActionBar component
-- Badge detail page streamlined with unified tab bar
-
-### Fixed
-- Hashtags now support accented and Unicode characters
-- Letter compose opens correctly from notifications and the letters page
-- Letter font picker loads fonts so each option previews in the correct typeface
-- Zap comment positioned inside the right column instead of floating with offset
-- Safe-area padding on pinned SubHeaderBar only applies when scrolled to top
-
-## [2.2.5] - 2026-03-30
-
-### Fixed
-- Crash when dragging profile tabs to reorder them
-
-## [2.2.4] - 2026-03-30
-
-### Changed
-- Profiles now have an emoji reaction button instead of a zap button -- express yourself with any emoji or custom emoji right on someone's profile
-- Zap moved to the profile overflow menu so it's still one tap away
-
-### Fixed
-- Crash on the notifications page caused by malformed badge award tags
-- Deleting a badge now also deletes all awards you issued for it
-- Custom emoji reactions missing their image tag no longer render as broken shortcodes
-- Deletion requests for addressable events now include both `e` and `a` tags for broader relay compatibility
-- Profile reactions no longer collapse into a single grouped notification
-- Oversized reaction emoji in comment context headers
-
-## [2.2.3] - 2026-03-30
-
-### Added
-- Letters now have an overflow menu, reply button, and a grid layout for browsing
-- Independent feed toggles for comments and generic reposts in content settings
-- Sidebar items are now visible to logged-out users so newcomers can explore everything
-
-### Changed
-- Compose textarea expands smoothly as you type instead of snapping to a new height
-- Blobbi stickers auto-shrink near card edges and clip cleanly at rounded boundaries
-
-### Fixed
-- Feed gaps when replies are disabled no longer cause missing posts
-- Avatar shape no longer flashes on load
-- Top bar arc no longer flickers during navigation transitions
-- Letter drawing-only sends, sticker drag bounds, and theme event preservation
-- Notification rendering for badges and letters
-- Duplicate React keys in content settings
-- Layout rendering warning when switching views
-
-## [2.2.2] - 2026-03-29
-
-### Added
-- Dedicated photo upload flow for sharing photos
-- Pull-to-refresh on all feed pages
-- 3D tilt effect on badge images -- hover over badges to see them pop
-- Multi-select badge awarding with indicators for already-sent badges
-- Badge list recovery dialog for restoring profile badge lists
-- Compact badge row preview in embedded profile badges events
-- Custom emoji usage tracking so your most-used custom emojis appear in the quick-react bar
-- Release notes now included in Zapstore publishing
-- Changelog link in the app footer
-
-### Changed
-- "Vines" renamed to "Divines" everywhere in the app
-- Custom emojis appear first in the emoji picker, right after recent
-- Threaded comment view now shows the parent event as a NoteCard with kind action headers
-
-### Fixed
-- Delete post dialog no longer freezes the feed on desktop
-- Amber login on Android now properly retries when returning from the background
-- Key downloads on Android save to the correct location
-- Custom emoji SVGs render correctly in the emoji-mart picker
-- Double-tap reactions now properly show the emoji on the post
-- Emoji shortcode autocomplete text and highlight colors
-- Profile skeleton no longer flickers for brand-new users with no metadata
-- Event links now route correctly for all event types
-- Badge notifications are now clickable
-- Custom profile tab form no longer retains fields from a previously edited tab
-- Double line under profile tabs in edit mode
-- Inconsistent use of "geocache" vs "treasures" terminology
-- Search page "N new posts" pill no longer shows unfiltered count
-- Stale-cache overwrites in replaceable event mutations
-- Click-through on delete confirmation and note menu items
-
-## [2.2.1] - 2026-03-28
-
-### Fixed
-- New posts no longer cause scroll jumps -- they buffer while you're reading and appear with a tap
-- Mobile header no longer shows double-layered backgrounds on notched devices
-- Pinned tabs stay properly positioned when scrolling on mobile
-- Signer approval toasts no longer fire in rapid succession on unstable connections
-- Toasts are easier to swipe away on mobile
-- Content warnings now blur thumbnails in the media grid
-
-## [2.2.0] - 2026-03-28
-
-### Added
-- Blobbi virtual pets -- adopt an egg, hatch it, evolve it into one of 16 adult forms, and care for it with feeding, cleaning, medicine, music, and singing
-- Blobbi companion that follows you around the app, tracks your cursor, blinks, expresses emotions, and reacts to what you're doing
-- Blobbi shop and inventory system with items that affect your pet's stats
-- Daily missions with reroll, care streaks, and stage-based rewards
-- Immersive full-screen divines experience on both mobile and desktop with floating controls
-- Relay information panel on the network settings page
-- Link preview cards now display inside quoted posts instead of raw URLs
-- Nsec paste guard warns you before accidentally pasting private keys outside the login field
-- Remote signer UX improvements for Amber users on Android
-- Badge awards now trigger push notifications
-- Badges display in profile bio section with a "Give badge" option in the profile menu
-
-### Changed
-- Notification "Mentions" tab now shows only pure mentions, filtering out replies
-- Notification preferences ("only from people I follow") now properly apply to push notifications, native Android notifications, and the unread dot
-- Upgraded from React 18 to React 19
-- Reduced initial bundle size by ~50% with improved code splitting and lazy loading
-
-### Fixed
-- Zapping Primal users no longer produces an error
-- Hashtag feeds now match case-insensitively for parity with search results
-- Mobile top bar arc no longer lingers on pages without tabs
-- Give Badge dialog and profile menu action handlers
-
-## [2.1.1] - 2026-03-27
-
-### Added
-- Emoji picker and shortcode autocomplete in zap comment box
-- Zap button on badge detail view
-- Theme descriptions now display on "updated their theme" posts and detail pages
-- Badge thumbnail previews in award notifications
-- Letter notifications with envelope card preview
-- Kind-specific labels in notification text instead of generic "post"
-
-### Fixed
-- Compose modal no longer closes when dismissing emoji picker on mobile
-- Compose preview overflow is now scrollable in modal
-- Toast notifications swipe up to dismiss on mobile instead of sideways
-- File downloads and URL opening work correctly on iOS
-- Badges page no longer shows infinite skeleton when logged out
-
-## [2.1.0] - 2026-03-26
-
-### Added
-- Letters -- a Wii Mail-inspired inbox for sending decorated letters to friends, complete with custom stationery, hand-drawn stickers, emoji stickers, fonts, and a send animation with envelope and wax seal
-- Attach a color moment or theme to your letter as a gift -- recipients can tap to apply it instantly
-- Stationery picker pulls from your color moments, followed users' themes, and built-in presets
-- Freehand drawing canvas for creating one-of-a-kind sticker doodles
-- Letters page added to the sidebar with a custom mailbox icon
-
-## [2.0.1] - 2026-03-26
-
-### Added
-- Tap the version number in settings to see what's new
-
-## [2.0.0] - 2026-03-26
-
-Initial release of Ditto 2.0 -- a complete rewrite of Ditto.
+- Initial Agora 3 release.

public/logo.svg

@@ -1,32 +1,17 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?xml version="1.0" encoding="UTF-8"?>
 <svg
-   version="1.1"
-   viewBox="-5 -10 100 100"
-   id="svg6"
-   width="100"
-   height="100"
-   xmlns="http://www.w3.org/2000/svg"
-   xmlns:svg="http://www.w3.org/2000/svg">
-  <defs
-     id="defs6" />
+  xmlns="http://www.w3.org/2000/svg"
+  width="24"
+  height="24"
+  viewBox="0 0 24 24"
+  fill="none"
+>
   <path
-     d="m 71.719615,49.36907 -0.62891,0.37109 c -0.12891,0.07031 -0.26172,0.14844 -0.39062,0.21875 -3.9883,10.309 -14.008,17.617 -25.699,17.617 -4.1211,0 -8.0312,-0.89844 -11.539,-2.5391 -0.12891,0.03906 -0.26172,0.07031 -0.39063,0.10156 l -0.35156,0.08984 h -0.02734 l -0.25,0.05859 -0.07813,0.01953 -0.10938,0.03125 c -0.55859,0.12891 -1.1289,0.26172 -1.6992,0.39062 -0.10156,0.03125 -0.19922,0.05078 -0.30078,0.07031 l -0.30078,0.10156 -0.18359,0.0078 c -0.26953,0.05859 -1.3086,0.26953 -1.3086,0.26953 -0.28906,0.05859 -0.55859,0.10937 -0.82813,0.17187 4.9805,3.3086 10.961,5.2305 17.371,5.2305 15.059,0 27.699,-10.602 30.828,-24.738 -0.75,0.48828 -1.5195,0.96875 -2.2891,1.4414 -0.59375,0.36328 -1.2031,0.72656 -1.8242,1.0859 z"
-     id="path1"
-     style="fill:#7c52e0;fill-opacity:1" />
-  <path
-     d="m 30.926615,29.47807 c 0.36328,-0.48828 0.75,-0.95312 1.1523,-1.3828 0.75781,-0.80469 0.71484,-2.0703 -0.08984,-2.8281 -0.80469,-0.75781 -2.0703,-0.71484 -2.8281,0.08984 -0.50781,0.53906 -0.99219,1.125 -1.4492,1.7383 -0.65625,0.88672 -0.47266,2.1406 0.41406,2.7969 0.35938,0.26562 0.77344,0.39453 1.1875,0.39453 0.61719,0 1.2227,-0.27734 1.6133,-0.80859 z"
-     id="path2"
-     style="fill:#7c52e0;fill-opacity:1" />
-  <path
-     d="m 26.742615,32.67807 c -1.0586,-0.3125 -2.1719,0.29687 -2.4805,1.3594 -0.55859,1.9062 -0.83984,3.9141 -0.83984,5.9609 0,2.3789 0.39062,4.7227 1.1602,6.9609 0.28516,0.82812 1.0625,1.3516 1.8906,1.3516 0.21484,0 0.43359,-0.03516 0.64844,-0.10938 1.043,-0.35938 1.6016,-1.4961 1.2422,-2.543 -0.625,-1.8203 -0.94141,-3.7227 -0.94141,-5.6602 0,-1.668 0.22656,-3.2969 0.67969,-4.8398 0.30859,-1.0586 -0.30078,-2.168 -1.3594,-2.4805 z"
-     id="path3"
-     style="fill:#7c52e0;fill-opacity:1" />
-  <path
-     d="m 14.691615,48.83807 c 0.10156,0.33984 0.19922,0.67969 0.32812,1.0195 0.42969,1.3516 0.94922,2.6484 1.5781,3.9102 0.10156,-0.01172 0.21094,-0.01172 0.32031,-0.01953 l 0.16016,-0.01172 0.80078,-0.07031 c 0.37109,-0.03906 0.67188,-0.07031 0.98047,-0.10156 0.51172,-0.05859 1.0195,-0.12109 1.5586,-0.19922 l 0.21875,-0.03125 c 0.07031,-0.01172 0.14062,-0.01953 0.21094,-0.03125 -1.2188,-2.2109 -2.1484,-4.6016 -2.7305,-7.1211 -0.16016,-0.71094 -0.30078,-1.4297 -0.39844,-2.1602 -0.19922,-1.3086 -0.30078,-2.6602 -0.30078,-4.0312 0,-0.89844 0.03906,-1.7812 0.12891,-2.6484 0.07031,-0.71094 0.16016,-1.4102 0.28906,-2.1016 2.25,-12.949 13.57,-22.828 27.16,-22.828 6.0508,0 11.648,1.9609 16.211,5.3008 0.57031,0.41016 1.1289,0.85938 1.6719,1.3203 1.6914,1.4219 3.2109,3.0703 4.5,4.8789 0.42969,0.60156 0.83984,1.2109 1.2188,1.8398 1.3203,2.1602 2.3398,4.5117 3.0195,7 0.23828,-0.17188 0.42969,-0.30859 0.62891,-0.46875 0.64844,-0.48047 1.2109,-0.92188 1.7383,-1.3398 0.28125,-0.23047 0.5,-0.41016 0.71094,-0.57812 0.10156,-0.07813 0.19141,-0.16016 0.28125,-0.23828 -0.42969,-1.3516 -0.96094,-2.6484 -1.5898,-3.8984 -0.14062,-0.32812 -0.30859,-0.64844 -0.48047,-0.96875 -0.32812,-0.64844 -0.69922,-1.2891 -1.0898,-1.9102 -1.6797,-2.7109 -3.7695,-5.1406 -6.1719,-7.2188 -0.57031,-0.48828 -1.1484,-0.96875 -1.7617,-1.4102 -0.55859,-0.42188 -1.1406,-0.82812 -1.7305,-1.2109 -4.9414,-3.2188 -10.852,-5.0898 -17.16,-5.0898 -14.961,0 -27.531,10.469 -30.75,24.469 -0.17188,0.67969 -0.30859,1.3711 -0.42188,2.0703 -0.12891,0.73828 -0.21875,1.5 -0.28906,2.2617 -0.07813,0.91016 -0.12109,1.8398 -0.12109,2.7812 0,2.3008 0.25,4.5508 0.71875,6.7109 0.17188,0.71484 0.35156,1.4258 0.5625,2.125 z"
-     id="path4"
-     style="fill:#7c52e0;fill-opacity:1" />
-  <path
-     d="m 90.441615,21.60007 c -2.1797,-5.3398 -9.4102,-7.3984 -21,-6.0391 1.8906,1.8906 3.5391,3.9688 4.9297,6.2109 0.28906,0.46094 0.55859,0.92187 0.80859,1.3789 5.5391,-0.12109 7.6094,1.0391 7.8398,1.4492 0.12891,0.46875 -0.55078,2.7305 -4.5898,6.4805 -0.01953,0.01953 -0.03125,0.03125 -0.03906,0.03906 -0.26172,0.23828 -0.51953,0.48047 -0.80078,0.71875 -0.19922,0.17969 -0.41016,0.35938 -0.62891,0.53906 -0.10938,0.10156 -0.21875,0.19141 -0.33984,0.28906 -0.23828,0.19922 -0.5,0.41016 -0.76172,0.62109 -0.12891,0.10156 -0.26172,0.21094 -0.39844,0.32031 -0.42969,0.33984 -0.89063,0.69141 -1.3711,1.0508 -0.26953,0.21094 -0.53906,0.41016 -0.82812,0.60938 -0.32031,0.23047 -0.64062,0.46875 -0.98047,0.69922 0,0.01172 -0.01172,0.01172 -0.01172,0.01172 -0.26953,0.19141 -0.55078,0.37891 -0.82812,0.57031 -0.28125,0.19141 -0.55859,0.37109 -0.85156,0.55859 -0.25,0.16016 -0.5,0.32812 -0.76172,0.48828 -6,3.8984 -13.48,7.7188 -21.379,10.922 -8.0117,3.2383 -15.871,5.6602 -22.93,7.0391 -0.30078,0.05859 -0.60156,0.12109 -0.89062,0.17188 -0.60938,0.12109 -1.2188,0.21875 -1.8203,0.32031 -0.07031,0.01172 -0.12891,0.01953 -0.19922,0.03125 h -0.01953 c -0.28906,0.05078 -0.57031,0.08984 -0.83984,0.12891 -0.30859,0.05078 -0.60938,0.08984 -0.91016,0.12891 -0.57031,0.07813 -1.1094,0.14844 -1.6406,0.21094 -0.35156,0.03906 -0.69141,0.07031 -1.0195,0.10156 -0.30078,0.03125 -0.58984,0.05078 -0.87891,0.07813 -0.48047,0.03125 -0.92969,0.05859 -1.3711,0.07813 -0.39844,0.01953 -0.78125,0.03125 -1.1484,0.03906 -5.5116996,0.10938 -7.5702996,-1.0391 -7.8007996,-1.4492 -0.12891,-0.48047 0.55078,-2.7383 4.6093996,-6.5 -0.12891,-0.48828 -0.26172,-1 -0.37891,-1.5391 -0.51953,-2.4219 -0.78906,-4.8906 -0.78906,-7.3594 0,-0.17969 0,-0.37109 0.01172,-0.55078 -9.2733996,7.082 -13.0229996,13.59 -10.8749996,18.949 1.7383,4.2695 6.7188,6.4492 14.5899996,6.4492 2.8594,0 6.1016,-0.28906 9.7109,-0.87109 0.17188,-0.03125 0.33984,-0.05859 0.51953,-0.08984 0.17188,-0.03125 0.35156,-0.05859 0.51953,-0.08984 l 1.2188,-0.21875 c 0.57031,-0.10156 1.1484,-0.21875 1.7305,-0.33984 0.53125,-0.10938 1.0508,-0.21094 1.5781,-0.32812 0.01172,0 0.03125,-0.01172 0.03906,-0.01172 0.05078,-0.01172 0.08984,-0.01953 0.14062,-0.03125 0.07031,-0.01172 0.12891,-0.03125 0.19922,-0.05078 0.57812,-0.12891 1.1602,-0.26172 1.7383,-0.39844 0.05078,-0.01172 0.10156,-0.03125 0.14844,-0.03906 0.21094,-0.05078 0.42188,-0.10156 0.64062,-0.14844 h 0.01172 c 6.0898,-1.5117 12.559,-3.6406 19.102,-6.2891 6.5508,-2.6602 12.68,-5.6289 18.109,-8.7812 0.21875,-0.12891 0.44141,-0.26172 0.66016,-0.39062 0.58984,-0.33984 1.1797,-0.69141 1.7617,-1.0508 1.5703,-0.96094 3.0586,-1.9297 4.4805,-2.9102 0.12891,-0.08984 0.26172,-0.17969 0.39062,-0.26953 11.242,-7.8477 15.941,-15.09 13.594,-20.938 z"
-     id="path5"
-     style="fill:#7c52e0;fill-opacity:1" />
+    d="M13 2L3 14h8l-1 8 10-12h-8l1-8z"
+    fill="black"
+    stroke="black"
+    stroke-width="1.5"
+    stroke-linecap="round"
+    stroke-linejoin="round"
+  />
 </svg>

public/manifest.webmanifest

@@ -1,11 +1,11 @@
 {
-  "name": "Ditto",
-  "short_name": "Ditto",
-  "description": "A carnival, not a platform. Color, whimsy, games, and endless customization — the most fun you've had on the internet in years.",
+  "name": "Agora",
+  "short_name": "Agora",
+  "description": "Power to the people. Organize, create, and connect across the open Nostr network.",
   "start_url": "/",
   "display": "standalone",
-  "background_color": "#161b2e",
-  "theme_color": "#7c3aed",
+  "background_color": "#0a0c14",
+  "theme_color": "#e85d3c",
   "icons": [
     {
       "src": "/icon-192.png",
@@ -87,5 +87,18 @@
       "type": "image/png",
       "form_factor": "narrow"
     }
-  ]
+  ],
+  "related_applications": [
+    {
+      "platform": "play",
+      "url": "https://play.google.com/store/apps/details?id=pub.ditto.app",
+      "id": "pub.ditto.app"
+    },
+    {
+      "platform": "itunes",
+      "url": "https://apps.apple.com/us/app/ditto-fun-social-media/id6761851821",
+      "id": "6761851821"
+    }
+  ],
+  "prefer_related_applications": false
 }

public/sw.js

@@ -1,5 +1,5 @@
 /**
- * Ditto Service Worker
+ * Agora Service Worker
  *
  * Handles incoming Web Push notifications from the nostr-push server and
  * opens/focuses the app when the user taps a notification.
@@ -14,17 +14,17 @@ self.addEventListener('push', (event) => {
   try {
     payload = event.data.json();
   } catch {
-    payload = { title: 'Ditto', body: event.data.text() };
+    payload = { title: 'Agora', body: event.data.text() };
   }
 
-  const title = payload.title ?? 'Ditto';
+  const title = payload.title ?? 'Agora';
   const options = {
     body: payload.body ?? '',
     icon: payload.icon ?? '/icon-192.png',
     badge: payload.badge ?? '/icon-192.png',
     data: payload.data ?? {},
     requireInteraction: false,
-    tag: payload.data?.subscription_id ?? 'ditto-notification',
+    tag: payload.data?.subscription_id ?? 'agora-notification',
     renotify: true,
   };
 
@@ -42,7 +42,7 @@ self.addEventListener('notificationclick', (event) => {
     self.clients
       .matchAll({ type: 'window', includeUncontrolled: true })
       .then((clientList) => {
-        // Focus an existing Ditto tab if one is open
+        // Focus an existing Agora tab if one is open
         for (const client of clientList) {
           if (new URL(client.url).origin === self.location.origin) {
             client.navigate('/notifications');

public/theme.js

@@ -4,8 +4,8 @@
 (function () {
   // Builtin themes — must match builtinThemes in src/themes.ts
   var builtins = {
-    dark:  { bg: 'hsl(228 20% 10%)', primary: 'hsl(258 70% 60%)' },
-    light: { bg: 'hsl(270 50% 97%)', primary: 'hsl(270 65% 55%)' }
+    dark:  { bg: 'hsl(0 0% 10%)', primary: 'hsl(15 90% 52%)' },
+    light: { bg: 'hsl(0 0% 100%)', primary: 'hsl(15 90% 48%)' }
   };
 
   var theme = 'dark';

scripts/extract-release-notes.mjs

@@ -0,0 +1,141 @@
+#!/usr/bin/env node
+/**
+ * Extract release notes from CHANGELOG.md for a given version.
+ *
+ * The CHANGELOG follows Keep a Changelog format with one extension: each release
+ * section MAY begin with a single plaintext paragraph (the "summary") before any
+ * `### Added` / `### Changed` / etc. heading. The summary is used as the release
+ * blurb on the App Store, Play Store, and the in-app version-update toast. The
+ * full section body is used as the GitLab Release description.
+ *
+ * Format:
+ *
+ *   ## [X.Y.Z] - YYYY-MM-DD
+ *
+ *   A short single-paragraph summary (max 500 characters by convention).
+ *
+ *   ### Added
+ *   - bullet
+ *   - bullet
+ *
+ *   ### Changed
+ *   - bullet
+ *
+ * Usage:
+ *   node scripts/extract-release-notes.mjs <version> [--summary] [--changelog <path>]
+ *
+ * --summary    Print only the summary paragraph (no headings, no bullets).
+ *              Falls back to "Ditto vX.Y.Z" if the section has no summary.
+ * --changelog  Path to the changelog file. Defaults to CHANGELOG.md.
+ *
+ * Exits 0 with the extracted text on stdout. Exits non-zero if the version is
+ * not found in the changelog.
+ */
+
+import { readFileSync } from 'node:fs';
+import { argv, exit, stderr, stdout } from 'node:process';
+
+function parseArgs(args) {
+  let version;
+  let summary = false;
+  let changelog = 'CHANGELOG.md';
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--summary') summary = true;
+    else if (arg === '--changelog') changelog = args[++i];
+    else if (!arg.startsWith('--') && !version) version = arg;
+    else {
+      stderr.write(`Unknown argument: ${arg}\n`);
+      exit(2);
+    }
+  }
+  if (!version) {
+    stderr.write('Usage: extract-release-notes.mjs <version> [--summary] [--changelog <path>]\n');
+    exit(2);
+  }
+  // Strip a leading "v" so callers can pass either "v2.14.3" or "2.14.3".
+  if (version.startsWith('v')) version = version.slice(1);
+  return { version, summary, changelog };
+}
+
+/**
+ * Extract the lines belonging to a single version section from changelog text,
+ * not including the version heading itself.
+ */
+function extractSection(markdown, version) {
+  const lines = markdown.split('\n');
+  const headingPattern = new RegExp(
+    `^## \\[${version.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\$&')}\\]`,
+  );
+  const nextHeadingPattern = /^## \[/;
+  let inSection = false;
+  const out = [];
+  for (const line of lines) {
+    if (!inSection) {
+      if (headingPattern.test(line)) {
+        inSection = true;
+        continue;
+      }
+    } else {
+      if (nextHeadingPattern.test(line)) break;
+      out.push(line);
+    }
+  }
+  return inSection ? out : null;
+}
+
+/**
+ * Pull the leading non-blank paragraph from a section, stopping at the first
+ * `###` category heading or `-` bullet. Returns null if no summary paragraph.
+ */
+function extractSummary(sectionLines) {
+  const paragraph = [];
+  let started = false;
+  for (const line of sectionLines) {
+    const trimmed = line.trim();
+    if (!started) {
+      if (!trimmed) continue;
+      // If the very first non-blank line is a heading or bullet, there's no summary.
+      if (trimmed.startsWith('#') || trimmed.startsWith('- ')) return null;
+      started = true;
+      paragraph.push(trimmed);
+      continue;
+    }
+    // We're inside the paragraph. A blank line, a heading, or a bullet ends it.
+    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('- ')) break;
+    paragraph.push(trimmed);
+  }
+  return paragraph.length ? paragraph.join(' ') : null;
+}
+
+/** Trim leading and trailing blank lines from a list of lines. */
+function trimBlankEdges(lines) {
+  let start = 0;
+  let end = lines.length;
+  while (start < end && !lines[start].trim()) start++;
+  while (end > start && !lines[end - 1].trim()) end--;
+  return lines.slice(start, end);
+}
+
+const { version, summary, changelog } = parseArgs(argv.slice(2));
+const markdown = readFileSync(changelog, 'utf8');
+const section = extractSection(markdown, version);
+
+if (!section) {
+  stderr.write(`Version ${version} not found in ${changelog}\n`);
+  exit(1);
+}
+
+if (summary) {
+  const text = extractSummary(section);
+  stdout.write(text ?? `Ditto v${version}`);
+  stdout.write('\n');
+} else {
+  const body = trimBlankEdges(section).join('\n');
+  if (body) {
+    stdout.write(body);
+    stdout.write('\n');
+  } else {
+    stdout.write(`Ditto v${version}\n`);
+  }
+}

scripts/nip46-auth.mjs

@@ -33,7 +33,7 @@ function parseArgs() {
   const args = process.argv.slice(2);
   const result = {
     relays: [],
-    name: 'Ditto',
+    name: 'Agora',
     timeout: 300, // seconds
   };
 
@@ -54,9 +54,9 @@ function parseArgs() {
 
 Options:
   --relay <url>    Relay URL for NIP-46 communication (repeatable)
-                   Default: wss://relay.ditto.pub
+                   Default: wss://relay.agora.spot
   --name <name>    Application name shown to the signer
-                   Default: Ditto
+                   Default: Agora
   --timeout <sec>  How long to wait for signer approval (seconds)
                    Default: 300 (5 minutes)
   --help, -h       Show this help message
@@ -66,7 +66,7 @@ Options:
   }
 
   if (result.relays.length === 0) {
-    result.relays.push('wss://relay.ditto.pub');
+    result.relays.push('wss://relay.agora.spot');
   }
 
   return result;

src/App.tsx

@@ -1,14 +1,12 @@
 // NOTE: This file should normally not be modified unless you are adding a new provider.
 // To add new routes, edit the AppRouter.tsx file.
 
-import { Capacitor, SystemBars, SystemBarsStyle } from "@capacitor/core";
 import { NostrLoginProvider } from "@nostrify/react/login";
 import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
 import { InferSeoMetaPlugin } from "@unhead/addons";
 import { createHead, UnheadProvider } from "@unhead/react/client";
-import { useEffect } from "react";
 import { AppProvider } from "@/components/AppProvider";
-import { DMProvider, type DMConfig } from "@/components/DMProvider";
+import { DMProviderWrapper } from "@/components/DMProviderWrapper";
 import { InitialSyncGate } from "@/components/InitialSyncGate";
 import { NativeNotifications } from "@/components/NativeNotifications";
 import NostrProvider from "@/components/NostrProvider";
@@ -21,17 +19,12 @@ import { TooltipProvider } from "@/components/ui/tooltip";
 import { useNsecPasteGuard } from "@/hooks/useNsecPasteGuard";
 import type { AppConfig } from "@/contexts/AppContext";
 import { NWCProvider } from "@/contexts/NWCContext";
-import { PROTOCOL_MODE } from "@/lib/dmConstants";
-import { DittoConfigSchema, type DittoConfig } from "@/lib/schemas";
+import { SparkWalletProvider } from "@/contexts/SparkWalletContext";
+import { BuildConfigSchema, type BuildConfig } from "@/lib/schemas";
 import { secureStorage } from "@/lib/secureStorage";
-import { EmotionDevProvider } from "@/blobbi/dev/EmotionDevContext";
+import { PROTOCOL_MODE } from "@samthomson/nostr-messaging/core";
 import AppRouter from "./AppRouter";
 
-const dmConfig: DMConfig = {
-  enabled: false,
-  protocolMode: PROTOCOL_MODE.NIP04_OR_NIP17,
-};
-
 const head = createHead({
   plugins: [InferSeoMetaPlugin()],
 });
@@ -48,14 +41,15 @@ const queryClient = new QueryClient({
 
 /** Hardcoded fallback values. Always provides every required field. */
 const hardcodedConfig: AppConfig = {
-  appName: "Ditto",
-  appId: "ditto",
+  appName: "Agora",
+  appId: "agora",
+  shareOrigin: import.meta.env.VITE_SHARE_ORIGIN || undefined,
   homePage: "feed",
   client: "naddr1qvzqqqru7cpzq7q6z5ns2hm5c8msyv83qwzxpxe52j8c4d4q5m92wsp9sflelkh9qqzkg6t5w3hswjl4yp",
   magicMouse: false,
   theme: "system",
-  autoShareTheme: true,
   useAppRelays: true,
+  useUserRelays: false,
   relayMetadata: {
     relays: [],
     updatedAt: 0,
@@ -65,8 +59,12 @@ const hardcodedConfig: AppConfig = {
     feedIncludeComments: true,
     feedIncludeReposts: true,
     feedIncludeGenericReposts: true,
+    feedIncludeReactions: false,
+    feedIncludeZaps: false,
     feedIncludeArticles: true,
     showArticles: true,
+    showHighlights: true,
+    feedIncludeHighlights: false,
     showEvents: true,
     feedIncludeEvents: true,
     showVines: true,
@@ -75,13 +73,13 @@ const hardcodedConfig: AppConfig = {
     showTreasureGeocaches: true,
     showTreasureFoundLogs: true,
     showColors: true,
-    showPacks: true,
+    showPeopleLists: true,
     feedIncludeVines: true,
     feedIncludePolls: true,
     feedIncludeTreasureGeocaches: true,
     feedIncludeTreasureFoundLogs: true,
     feedIncludeColors: true,
-    feedIncludePacks: true,
+    feedIncludePeopleLists: true,
     showDecks: true,
     feedIncludeDecks: true,
     showWebxdc: true,
@@ -91,13 +89,6 @@ const hardcodedConfig: AppConfig = {
     showVideos: true,
     feedIncludeNormalVideos: true,
     feedIncludeShortVideos: true,
-    showProfileThemes: false,
-    feedIncludeProfileThemes: true,
-    showThemeDefinitions: true,
-    feedIncludeThemeDefinitions: true,
-    showProfileThemeUpdates: true,
-    feedIncludeProfileThemeUpdates: true,
-    showCustomProfileThemes: true,
     feedIncludeVoiceMessages: true,
     showEmojiPacks: true,
     feedIncludeEmojiPacks: true,
@@ -111,26 +102,35 @@ const hardcodedConfig: AppConfig = {
     feedIncludePodcastTrailers: true,
     showDevelopment: true,
     feedIncludeDevelopment: true,
+    showCommunities: true,
+    feedIncludeCommunities: true,
     showBadges: true,
     showBadgeDefinitions: true,
     showProfileBadges: true,
+    showBadgeAwards: true,
     feedIncludeBadgeDefinitions: true,
     feedIncludeProfileBadges: true,
+    feedIncludeBadgeAwards: true,
     feedIncludeVanish: true,
-    feedIncludeBlobbi: true,
+    showBirdstar: true,
+    feedIncludeBirdDetections: true,
+    feedIncludeBirdex: true,
+    feedIncludeConstellations: true,
     followsFeedShowReplies: true,
   },
   sidebarOrder: [
+    "wallet",
+    "verified",
+    "actions",
+    "polls",
+    "world",
+    "badges",
     "feed",
     "notifications",
-    "search",
-    "blobbi",
-    "badges",
-    "emojis",
-    "letters",
-    "themes",
+    "messages",
+    "communities",
+    "profile",
     "settings",
-    "help",
   ],
   nip85StatsPubkey:
     "5f68e85ee174102ca8978eef302129f081f03456c884185d5ec1c1224ab633ea",
@@ -148,56 +148,55 @@ const hardcodedConfig: AppConfig = {
   plausibleDomain: import.meta.env.VITE_PLAUSIBLE_DOMAIN || "",
   plausibleEndpoint: import.meta.env.VITE_PLAUSIBLE_ENDPOINT || "",
   savedFeeds: [],
+  autoplayVideos: false,
   imageQuality: 'compressed',
   curatorPubkey: '932614571afcbad4d17a191ee281e39eebbb41b93fac8fd87829622aeb112f4d',
   sandboxDomain: 'iframe.diy',
+  esploraBaseUrl: 'https://mempool.space/api',
   sidebarWidgets: [
     { id: 'trends' },
     { id: 'hot-posts' },
-    { id: 'wikipedia' },
   ],
+  messaging: {
+    enabled: true,
+    relayMode: 'hybrid',
+    protocolMode: PROTOCOL_MODE.NIP17_ONLY,
+    renderInlineMedia: true,
+    soundEnabled: false,
+    devMode: false,
+  },
 };
 
 /**
- * Parse and validate build-time ditto.json overrides from the env string.
+ * Parse and validate build-time app config overrides from the env string.
  * Returns an empty object when no config file was provided or validation fails.
  */
-function parseDittoConfig(): DittoConfig {
+function parseBuildConfig(): BuildConfig {
   try {
-    const json = JSON.parse(import.meta.env.DITTO_CONFIG);
+    const encodedConfig = import.meta.env.APP_CONFIG ?? import.meta.env.DITTO_CONFIG;
+    const json = JSON.parse(encodedConfig);
     if (!json) return {};
-    return DittoConfigSchema.parse(json);
+    return BuildConfigSchema.parse(json);
   } catch {
     return {};
   }
 }
 
 /**
- * Merge hardcoded defaults with build-time ditto.json overrides.
+ * Merge hardcoded defaults with build-time config overrides.
  * Deep-merges feedSettings so a partial override doesn't erase defaults.
  * Precedence (handled by AppProvider): user localStorage > build-time > hardcoded.
  */
-const dittoConfig = parseDittoConfig();
+const buildConfig = parseBuildConfig();
 const defaultConfig: AppConfig = {
   ...hardcodedConfig,
-  ...dittoConfig,
-  feedSettings: { ...hardcodedConfig.feedSettings, ...dittoConfig.feedSettings },
+  ...buildConfig,
+  feedSettings: { ...hardcodedConfig.feedSettings, ...buildConfig.feedSettings },
 };
 
 export function App() {
   useNsecPasteGuard();
 
-  useEffect(() => {
-    // Initialize system bars for mobile apps.
-    // On Android 16+ (API 36), edge-to-edge is enforced by the OS so
-    // setOverlaysWebView / setBackgroundColor no longer work. The new
-    // SystemBars API (bundled with @capacitor/core 8+) is the replacement.
-    if (Capacitor.isNativePlatform()) {
-      SystemBars.setStyle({ style: SystemBarsStyle.Dark }).catch(() => {
-        // SystemBars may not be available on all platforms
-      });
-    }
-  }, []);
 
   return (
     <UnheadProvider head={head}>
@@ -211,15 +210,15 @@ export function App() {
                   <NativeNotifications />
 
                     <NWCProvider>
-                    <DMProvider config={dmConfig}>
-                      <EmotionDevProvider>
-                        <TooltipProvider>
-                          <InitialSyncGate>
-                            <AppRouter />
-                          </InitialSyncGate>
-                        </TooltipProvider>
-                      </EmotionDevProvider>
-                    </DMProvider>
+                    <SparkWalletProvider>
+                    <DMProviderWrapper>
+                      <TooltipProvider>
+                        <InitialSyncGate>
+                          <AppRouter />
+                        </InitialSyncGate>
+                      </TooltipProvider>
+                    </DMProviderWrapper>
+                    </SparkWalletProvider>
                   </NWCProvider>
                 </NostrProvider>
               </NostrLoginProvider>

src/AppRouter.tsx

@@ -4,7 +4,6 @@ import { AudioNavigationGuard } from "@/components/AudioNavigationGuard";
 import { DeepLinkHandler } from "@/components/DeepLinkHandler";
 import { MinimizedAudioBar } from "@/components/MinimizedAudioBar";
 import { AudioPlayerProvider } from "@/contexts/AudioPlayerContext";
-import { BlobbiActionsProvider } from "@/blobbi/companion/interaction/BlobbiActionsProvider";
 import { sidebarItemIcon } from "@/lib/sidebarItems";
 import { Toaster } from "./components/ui/toaster";
 import { MainLayout } from "./components/MainLayout";
@@ -17,9 +16,7 @@ import { getExtraKindDef } from "./lib/extraKinds";
 // Critical-path pages: eagerly loaded (landing + fallback)
 import Index from "./pages/Index";
 import NotFound from "./pages/NotFound";
-
-// Lazy-loaded companion layer (~450K code-split)
-const BlobbiCompanionLayer = lazy(() => import("@/blobbi/companion").then(m => ({ default: m.BlobbiCompanionLayer })));
+import MessagesPage from "./pages/Messages";
 
 // Lazy-loaded compose modal (pulls in emoji-mart ~620K)
 const ReplyComposeModal = lazy(() => import("@/components/ReplyComposeModal").then(m => ({ default: m.ReplyComposeModal })));
@@ -31,16 +28,18 @@ const EmojiPackDialog = lazy(() => import("@/components/EmojiPackDialog").then(m
 const HomePage = lazy(() => import("./pages/HomePage").then(m => ({ default: m.HomePage })));
 
 // All other pages: code-split via React.lazy
+const ActionsPage = lazy(() => import("./pages/ActionsPage"));
 const AdvancedSettingsPage = lazy(() => import("./pages/AdvancedSettingsPage").then(m => ({ default: m.AdvancedSettingsPage })));
 const AIChatPage = lazy(() => import("./pages/AIChatPage").then(m => ({ default: m.AIChatPage })));
+const AppearanceSettingsPage = lazy(() => import("./pages/AppearanceSettingsPage").then(m => ({ default: m.AppearanceSettingsPage })));
 const ArchivePage = lazy(() => import("./pages/ArchivePage").then(m => ({ default: m.ArchivePage })));
 const ArticleEditorPage = lazy(() => import("./pages/ArticleEditorPage").then(m => ({ default: m.ArticleEditorPage })));
 const BadgesPage = lazy(() => import("./pages/BadgesPage").then(m => ({ default: m.BadgesPage })));
-const BlobbiPage = lazy(() => import("./pages/BlobbiPage").then(m => ({ default: m.BlobbiPage })));
 const BlueskyPage = lazy(() => import("./pages/BlueskyPage").then(m => ({ default: m.BlueskyPage })));
 const BookmarksPage = lazy(() => import("./pages/BookmarksPage").then(m => ({ default: m.BookmarksPage })));
 const BooksPage = lazy(() => import("./pages/BooksPage").then(m => ({ default: m.BooksPage })));
 const ChangelogPage = lazy(() => import("./pages/ChangelogPage").then(m => ({ default: m.ChangelogPage })));
+const CommunitiesPage = lazy(() => import("./pages/CommunitiesPage").then(m => ({ default: m.CommunitiesPage })));
 const ContentPage = lazy(() => import("./pages/ContentPage").then(m => ({ default: m.ContentPage })));
 const ContentSettingsPage = lazy(() => import("./pages/ContentSettingsPage").then(m => ({ default: m.ContentSettingsPage })));
 const CSAEPolicyPage = lazy(() => import("./pages/CSAEPolicyPage").then(m => ({ default: m.CSAEPolicyPage })));
@@ -55,11 +54,13 @@ const LetterComposePage = lazy(() => import("./pages/LetterComposePage").then(m
 const LetterPreferencesPage = lazy(() => import("./pages/LetterPreferencesPage").then(m => ({ default: m.LetterPreferencesPage })));
 const LettersPage = lazy(() => import("./pages/LettersPage").then(m => ({ default: m.LettersPage })));
 const MagicSettingsPage = lazy(() => import("./pages/MagicSettingsPage").then(m => ({ default: m.MagicSettingsPage })));
-const MusicFeedPage = lazy(() => import("./pages/MusicFeedPage").then(m => ({ default: m.MusicFeedPage })));
+const MessagingSettingsPage = lazy(() => import("./pages/MessagingSettingsPage").then(m => ({ default: m.MessagingSettingsPage })));
+const MusicPage = lazy(() => import("./pages/MusicPage").then(m => ({ default: m.MusicPage })));
 const NetworkSettingsPage = lazy(() => import("./pages/NetworkSettingsPage").then(m => ({ default: m.NetworkSettingsPage })));
 const NIP19Page = lazy(() => import("./pages/NIP19Page").then(m => ({ default: m.NIP19Page })));
 const NotificationSettings = lazy(() => import("./pages/NotificationSettings").then(m => ({ default: m.NotificationSettings })));
 const NotificationsPage = lazy(() => import("./pages/NotificationsPage").then(m => ({ default: m.NotificationsPage })));
+const OrganizersPage = lazy(() => import("./pages/OrganizersPage").then(m => ({ default: m.OrganizersPage })));
 const PhotosFeedPage = lazy(() => import("./pages/PhotosFeedPage").then(m => ({ default: m.PhotosFeedPage })));
 const PodcastsFeedPage = lazy(() => import("./pages/PodcastsFeedPage").then(m => ({ default: m.PodcastsFeedPage })));
 const PrivacyPolicyPage = lazy(() => import("./pages/PrivacyPolicyPage").then(m => ({ default: m.PrivacyPolicyPage })));
@@ -67,12 +68,13 @@ const ProfileSettings = lazy(() => import("./pages/ProfileSettings").then(m => (
 const RelayPage = lazy(() => import("./pages/RelayPage").then(m => ({ default: m.RelayPage })));
 const SearchPage = lazy(() => import("./pages/SearchPage").then(m => ({ default: m.SearchPage })));
 const SettingsPage = lazy(() => import("./pages/SettingsPage").then(m => ({ default: m.SettingsPage })));
-const ThemesPage = lazy(() => import("./pages/ThemesPage").then(m => ({ default: m.ThemesPage })));
 const TreasuresPage = lazy(() => import("./pages/TreasuresPage").then(m => ({ default: m.TreasuresPage })));
 const TrendsPage = lazy(() => import("./pages/TrendsPage").then(m => ({ default: m.TrendsPage })));
 const UserListsPage = lazy(() => import("./pages/UserListsPage").then(m => ({ default: m.UserListsPage })));
+const VerifiedPage = lazy(() => import("./pages/VerifiedPage").then(m => ({ default: m.VerifiedPage })));
 const VideosFeedPage = lazy(() => import("./pages/VideosFeedPage").then(m => ({ default: m.VideosFeedPage })));
 const VinesFeedPage = lazy(() => import("./pages/VinesFeedPage").then(m => ({ default: m.VinesFeedPage })));
+const WalletPage = lazy(() => import("./pages/WalletPage").then(m => ({ default: m.WalletPage })));
 const WalletSettingsPage = lazy(() => import("./pages/WalletSettingsPage").then(m => ({ default: m.WalletSettingsPage })));
 const WebxdcFeedPage = lazy(() => import("./pages/WebxdcFeedPage").then(m => ({ default: m.WebxdcFeedPage })));
 const WikipediaPage = lazy(() => import("./pages/WikipediaPage").then(m => ({ default: m.WikipediaPage })));
@@ -87,6 +89,7 @@ const articlesDef = getExtraKindDef("articles")!;
 const decksDef = getExtraKindDef("decks")!;
 const emojisDef = getExtraKindDef("emojis")!;
 const developmentDef = getExtraKindDef("development")!;
+const highlightsDef = getExtraKindDef("highlights")!;
 
 /** Polls feed page with a FAB that opens the compose modal (poll mode via + menu). */
 function PollsFeedPage() {
@@ -146,11 +149,6 @@ export function AppRouter() {
         <AudioNavigationGuard />
         <DeepLinkHandler />
         <ScrollToTop />
-        <BlobbiActionsProvider>
-          <Suspense fallback={null}>
-            <BlobbiCompanionLayer />
-          </Suspense>
-        </BlobbiActionsProvider>
         <Routes>
           {/* Auto-follow deep link: fullscreen immersive (no sidebars/nav) */}
           <Route path="/follow/:npub" element={<FollowPage />} />
@@ -160,6 +158,7 @@ export function AppRouter() {
             <Route path="/" element={<HomePage />} />
             <Route path="/feed" element={<Index />} />
             <Route path="/notifications" element={<NotificationsPage />} />
+            <Route path="/messages" element={<MessagesPage />} />
             <Route path="/search" element={<SearchPage />} />
             <Route path="/trends" element={<TrendsPage />} />
             <Route path="/profile" element={<ProfileRedirect />} />
@@ -167,6 +166,7 @@ export function AppRouter() {
              <Route path="/g/:geohash" element={<GeotagPage />} />
             <Route path="/feed/:domain" element={<DomainFeedPage />} />
             <Route path="/settings" element={<SettingsPage />} />
+            <Route path="/settings/appearance" element={<AppearanceSettingsPage />} />
             <Route path="/settings/profile" element={<ProfileSettings />} />
             <Route path="/settings/feed" element={<ContentSettingsPage />} />
             <Route path="/settings/content" element={<ContentPage />} />
@@ -175,6 +175,7 @@ export function AppRouter() {
               path="/settings/notifications"
               element={<NotificationSettings />}
             />
+            <Route path="/settings/messaging" element={<MessagingSettingsPage />} />
             <Route
               path="/settings/advanced"
               element={<AdvancedSettingsPage />}
@@ -191,7 +192,7 @@ export function AppRouter() {
               element={<Navigate to="/videos" replace />}
             />
             <Route path="/vines" element={<VinesFeedPage />} />
-            <Route path="/music" element={<MusicFeedPage />} />
+            <Route path="/music" element={<MusicPage />} />
             <Route path="/podcasts" element={<PodcastsFeedPage />} />
             <Route path="/polls" element={<PollsFeedPage />} />
             <Route path="/treasures" element={<TreasuresPage />} />
@@ -229,6 +230,17 @@ export function AppRouter() {
                 />
               }
             />
+            <Route
+              path="/highlights"
+              element={
+                <KindFeedPage
+                  kind={highlightsDef.kind}
+                  title={highlightsDef.label}
+                  icon={sidebarItemIcon("highlights", "size-5")}
+                  showFAB={false}
+                />
+              }
+            />
             <Route
               path="/decks"
               element={
@@ -254,16 +266,17 @@ export function AppRouter() {
                 />
               }
             />
-            <Route path="/themes" element={<ThemesPage />} />
+            <Route path="/wallet" element={<WalletPage />} />
             <Route path="/bookmarks" element={<BookmarksPage />} />
             <Route path="/ai-chat" element={<AIChatPage />} />
-            <Route path="/blobbi" element={<BlobbiPage />} />
+            <Route path="/verified" element={<VerifiedPage />} />
             <Route path="/world" element={<WorldPage />} />
             <Route path="/badges" element={<BadgesPage />} />
             <Route path="/books" element={<BooksPage />} />
             <Route path="/archive" element={<ArchivePage />} />
             <Route path="/bluesky" element={<BlueskyPage />} />
             <Route path="/wikipedia" element={<WikipediaPage />} />
+            <Route path="/communities" element={<CommunitiesPage />} />
             <Route path="/letters" element={<LettersPage />} />
             <Route path="/letters/compose" element={<LetterComposePage />} />
             <Route path="/settings/letters" element={<LetterPreferencesPage />} />
@@ -277,6 +290,8 @@ export function AppRouter() {
               element={<Navigate to="/lists" replace />}
             />
             <Route path="/i/*" element={<ExternalContentPage />} />
+            <Route path="/actions" element={<ActionsPage />} />
+            <Route path="/organizers" element={<OrganizersPage />} />
 
             {/* Callback target for remote signers (e.g. Amber, Primal) after NIP-46 approval */}
             <Route path="/remoteloginsuccess" element={<RemoteLoginSuccessPage />} />

src/blobbi/actions/components/BlobbiActionInventoryModal.tsx

@@ -1,317 +0,0 @@
-// src/blobbi/actions/components/BlobbiActionInventoryModal.tsx
-
-import { useMemo } from 'react';
-import { Loader2, X } from 'lucide-react';
-
-import {
-  Dialog,
-  DialogContent,
-  DialogHeader,
-  DialogTitle,
-  DialogClose,
-} from '@/components/ui/dialog';
-import { Button } from '@/components/ui/button';
-
-import type { BlobbiCompanion, BlobbonautProfile } from '@/blobbi/core/lib/blobbi';
-import { cn } from '@/lib/utils';
-
-import {
-  filterInventoryByAction,
-  previewStatChanges,
-  previewMedicineForEgg,
-  previewCleanForEgg,
-  canUseAction,
-  getStageRestrictionMessage,
-  ACTION_METADATA,
-  type InventoryAction,
-  type ResolvedInventoryItem,
-  type EggStatPreview,
-} from '../lib/blobbi-action-utils';
-
-interface BlobbiActionInventoryModalProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  action: InventoryAction;
-  companion: BlobbiCompanion;
-  profile: BlobbonautProfile | null;
-  /** Called when user taps Use on an item. Always uses once. */
-  onUseItem: (itemId: string) => void;
-  onOpenShop: () => void;
-  isUsingItem: boolean;
-  usingItemId: string | null;
-}
-
-export function BlobbiActionInventoryModal({
-  open,
-  onOpenChange,
-  action,
-  companion,
-  profile: _profile,
-  onUseItem,
-  onOpenShop: _onOpenShop,
-  isUsingItem,
-  usingItemId,
-}: BlobbiActionInventoryModalProps) {
-  const actionMeta = ACTION_METADATA[action];
-
-  // Get all available items for this action from the catalog (not inventory).
-  // Items are abilities/tools — no ownership required.
-  const availableItems = useMemo(() => {
-    return filterInventoryByAction([], action, { stage: companion.stage });
-  }, [action, companion.stage]);
-
-  // Check stage restrictions for this specific action
-  const canUse = canUseAction(companion, action);
-  const stageMessage = getStageRestrictionMessage(companion, action);
-
-  const isEmpty = availableItems.length === 0;
-
-  const handleUseItem = (item: ResolvedInventoryItem) => {
-    if (isUsingItem) return;
-    onUseItem(item.itemId);
-  };
-
-  return (
-    <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent className="max-w-md w-[calc(100%-2rem)] max-h-[85vh] flex flex-col p-0 gap-0 [&>button:last-child]:hidden">
-        {/* Header - Sticky */}
-        <DialogHeader className="sticky top-0 z-10 bg-background px-4 sm:px-6 pt-4 sm:pt-6 pb-3 sm:pb-4 border-b">
-          <div className="flex items-start justify-between gap-3">
-            <div className="flex items-center gap-3 min-w-0">
-              <div className="size-9 sm:size-10 rounded-xl bg-gradient-to-br from-primary/20 to-primary/5 flex items-center justify-center text-xl sm:text-2xl shrink-0">
-                {actionMeta.icon}
-              </div>
-              <div className="min-w-0">
-                <DialogTitle className="text-lg sm:text-xl">{actionMeta.label}</DialogTitle>
-                <p className="text-xs sm:text-sm text-muted-foreground truncate">
-                  {actionMeta.description}
-                </p>
-              </div>
-            </div>
-            <DialogClose className="rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 shrink-0">
-              <X className="size-5" />
-              <span className="sr-only">Close</span>
-            </DialogClose>
-          </div>
-        </DialogHeader>
-
-        {/* Content - Scrollable */}
-        <div className="flex-1 min-h-0 overflow-y-auto px-4 sm:px-6 py-3 sm:py-4">
-          {/* Stage Restriction Message */}
-          {!canUse && stageMessage && (
-            <div className="flex flex-col items-center justify-center py-12 text-center">
-              <div className="size-16 rounded-2xl bg-amber-500/10 flex items-center justify-center mb-4">
-                <span className="text-3xl">🥚</span>
-              </div>
-              <h3 className="text-lg font-semibold mb-2">Not Available</h3>
-              <p className="text-sm text-muted-foreground max-w-sm">
-                {stageMessage}
-              </p>
-            </div>
-          )}
-
-          {/* Empty State */}
-          {canUse && isEmpty && (
-            <div className="flex flex-col items-center justify-center py-12 text-center">
-              <div className="size-16 rounded-2xl bg-muted/50 flex items-center justify-center mb-4">
-                <span className="text-3xl">{actionMeta.icon}</span>
-              </div>
-              <h3 className="text-lg font-semibold mb-2">No Items Available</h3>
-              <p className="text-sm text-muted-foreground max-w-sm">
-                No items are available for this action at your Blobbi's current stage.
-              </p>
-            </div>
-          )}
-
-          {/* Item List */}
-          {canUse && !isEmpty && (
-            <div className="grid gap-3">
-              {availableItems.map((item) => (
-                <BlobbiInventoryUseRow
-                  key={item.itemId}
-                  item={item}
-                  companion={companion}
-                  action={action}
-                  onUse={() => handleUseItem(item)}
-                  isUsing={isUsingItem && usingItemId === item.itemId}
-                  disabled={isUsingItem}
-                />
-              ))}
-            </div>
-          )}
-        </div>
-      </DialogContent>
-    </Dialog>
-  );
-}
-
-// ─── Inventory Use Row ────────────────────────────────────────────────────────
-
-interface BlobbiInventoryUseRowProps {
-  item: ResolvedInventoryItem;
-  companion: BlobbiCompanion;
-  action: InventoryAction;
-  onUse: () => void;
-  isUsing: boolean;
-  disabled: boolean;
-}
-
-function BlobbiInventoryUseRow({
-  item,
-  companion,
-  action,
-  onUse,
-  isUsing,
-  disabled,
-}: BlobbiInventoryUseRowProps) {
-  const isEgg = companion.stage === 'egg';
-  const isMedicine = action === 'medicine';
-  const isClean = action === 'clean';
-
-  // Preview stat changes - handle egg-specific preview for medicine and clean
-  const { normalStatChanges, eggStatChanges } = useMemo(() => {
-    if (isEgg && isMedicine) {
-      return {
-        normalStatChanges: [],
-        eggStatChanges: previewMedicineForEgg(companion.stats.health, item.effect),
-      };
-    }
-    if (isEgg && isClean) {
-      return {
-        normalStatChanges: [],
-        eggStatChanges: previewCleanForEgg(
-          { hygiene: companion.stats.hygiene, happiness: companion.stats.happiness },
-          item.effect
-        ),
-      };
-    }
-    return {
-      normalStatChanges: previewStatChanges(companion.stats, item.effect),
-      eggStatChanges: [] as EggStatPreview[],
-    };
-  }, [companion.stats, item.effect, isEgg, isMedicine, isClean]);
-
-  const hasChanges = normalStatChanges.length > 0 || eggStatChanges.length > 0;
-
-  return (
-    <div className="flex flex-col sm:flex-row sm:items-center gap-3 sm:gap-4 p-3 sm:p-4 rounded-xl border bg-card/60 backdrop-blur-sm hover:border-primary/30 transition-colors">
-      {/* Top row on mobile: Icon + Info + Button */}
-      <div className="flex items-center gap-3 sm:contents">
-        {/* Item Icon */}
-        <div className="relative shrink-0">
-          <div className="absolute inset-0 bg-gradient-to-br from-primary/20 to-primary/5 rounded-full blur-xl" />
-          <div className="relative size-10 sm:size-14 rounded-full bg-gradient-to-br from-primary/10 to-primary/5 flex items-center justify-center text-2xl sm:text-3xl">
-            {item.icon}
-          </div>
-        </div>
-
-        {/* Item Info */}
-        <div className="flex-1 min-w-0">
-          <div className="flex items-center gap-2 mb-0.5 sm:mb-1">
-            <h3 className="font-semibold text-sm sm:text-base truncate">{item.name}</h3>
-          </div>
-
-          {/* Effect Preview - shown inline on desktop */}
-          <div className="hidden sm:block">
-            {hasChanges && (
-              <div className="flex flex-wrap gap-x-3 gap-y-1">
-                {normalStatChanges.map(({ stat, delta }) => (
-                  <span key={stat} className="text-xs">
-                    <span
-                      className={cn(
-                        'font-medium',
-                        delta > 0
-                          ? 'text-emerald-600 dark:text-emerald-400'
-                          : 'text-red-600 dark:text-red-400'
-                      )}
-                    >
-                      {delta > 0 ? '+' : ''}
-                      {delta}
-                    </span>{' '}
-                    <span className="text-muted-foreground capitalize">
-                      {stat.replace('_', ' ')}
-                    </span>
-                  </span>
-                ))}
-                {eggStatChanges.map(({ stat, delta }) => (
-                  <span key={stat} className="text-xs">
-                    <span
-                      className={cn(
-                        'font-medium',
-                        delta > 0
-                          ? 'text-emerald-600 dark:text-emerald-400'
-                          : 'text-red-600 dark:text-red-400'
-                      )}
-                    >
-                      {delta > 0 ? '+' : ''}
-                      {delta}
-                    </span>{' '}
-                    <span className="text-muted-foreground capitalize">
-                      {stat.replace('_', ' ')}
-                    </span>
-                  </span>
-                ))}
-              </div>
-            )}
-          </div>
-        </div>
-
-        {/* Use Button */}
-        <Button
-          size="sm"
-          onClick={onUse}
-          disabled={disabled}
-          className="shrink-0"
-        >
-          {isUsing ? (
-            <Loader2 className="size-4 animate-spin" />
-          ) : (
-            'Use'
-          )}
-        </Button>
-      </div>
-
-      {/* Effect Preview - shown below on mobile */}
-      {hasChanges && (
-        <div className="sm:hidden flex flex-wrap gap-x-3 gap-y-1 pl-13">
-          {normalStatChanges.map(({ stat, delta }) => (
-            <span key={stat} className="text-xs">
-              <span
-                className={cn(
-                  'font-medium',
-                  delta > 0
-                    ? 'text-emerald-600 dark:text-emerald-400'
-                    : 'text-red-600 dark:text-red-400'
-                )}
-              >
-                {delta > 0 ? '+' : ''}
-                {delta}
-              </span>{' '}
-              <span className="text-muted-foreground capitalize">
-                {stat.replace('_', ' ')}
-              </span>
-            </span>
-          ))}
-          {eggStatChanges.map(({ stat, delta }) => (
-            <span key={stat} className="text-xs">
-              <span
-                className={cn(
-                  'font-medium',
-                  delta > 0
-                    ? 'text-emerald-600 dark:text-emerald-400'
-                    : 'text-red-600 dark:text-red-400'
-                )}
-              >
-                {delta > 0 ? '+' : ''}
-                {delta}
-              </span>{' '}
-              <span className="text-muted-foreground capitalize">
-                {stat.replace('_', ' ')}
-              </span>
-            </span>
-          ))}
-        </div>
-      )}
-    </div>
-  );
-}

src/blobbi/actions/components/BlobbiActionsModal.tsx

@@ -1,201 +0,0 @@
-// src/blobbi/actions/components/BlobbiActionsModal.tsx
-
-import { Loader2, Moon, Sun, Utensils, Gamepad2, Sparkles as SparklesIcon, Pill, Music, Mic, X } from 'lucide-react';
-
-import {
-  Dialog,
-  DialogContent,
-  DialogHeader,
-  DialogTitle,
-  DialogClose,
-} from '@/components/ui/dialog';
-import { Button } from '@/components/ui/button';
-
-import type { BlobbiCompanion } from '@/blobbi/core/lib/blobbi';
-import type { InventoryAction, DirectAction } from '../lib/blobbi-action-utils';
-
-interface BlobbiActionsModalProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  companion: BlobbiCompanion;
-  onRest: () => void;
-  onInventoryAction: (action: InventoryAction) => void;
-  onDirectAction: (action: DirectAction) => void;
-  actionInProgress: string | null;
-  isPublishing: boolean;
-}
-
-export function BlobbiActionsModal({
-  open,
-  onOpenChange,
-  companion,
-  onRest,
-  onInventoryAction,
-  onDirectAction,
-  actionInProgress,
-  isPublishing,
-}: BlobbiActionsModalProps) {
-  const isSleeping = companion.state === 'sleeping';
-  const isDisabled = isPublishing || actionInProgress !== null;
-  const isEgg = companion.stage === 'egg';
-
-  const handleAction = (action: () => void) => {
-    action();
-  };
-
-  return (
-    <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent className="max-w-sm w-[calc(100%-2rem)] max-h-[85vh] flex flex-col p-0 gap-0 [&>button:last-child]:hidden">
-        {/* Header - Sticky */}
-        <DialogHeader className="sticky top-0 z-10 bg-background px-4 sm:px-6 pt-4 sm:pt-6 pb-3 sm:pb-4 border-b">
-          <div className="flex items-start justify-between gap-4">
-            <div>
-              <DialogTitle>Blobbi Actions</DialogTitle>
-              <p className="text-sm text-muted-foreground">{companion.name}</p>
-            </div>
-            <DialogClose className="rounded-sm opacity-70 ring-offset-background transition-opacity hover:opacity-100 focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2">
-              <X className="size-5" />
-              <span className="sr-only">Close</span>
-            </DialogClose>
-          </div>
-        </DialogHeader>
-        {/* Content - Scrollable */}
-        <div className="flex-1 min-h-0 overflow-y-auto px-4 sm:px-6 py-3 sm:py-4">
-          <div className="grid gap-3">
-          {/* Feed Action - hidden for eggs */}
-          {!isEgg && (
-            <Button
-              variant="outline"
-              className="w-full justify-start gap-3 h-14"
-              onClick={() => handleAction(() => onInventoryAction('feed'))}
-              disabled={isDisabled}
-            >
-              <Utensils className="size-5 text-orange-500" />
-              <div className="text-left">
-                <p className="font-medium">Feed</p>
-                <p className="text-xs text-muted-foreground">
-                  Give your Blobbi something to eat
-                </p>
-              </div>
-            </Button>
-          )}
-
-          {/* Play Action - hidden for eggs */}
-          {!isEgg && (
-            <Button
-              variant="outline"
-              className="w-full justify-start gap-3 h-14"
-              onClick={() => handleAction(() => onInventoryAction('play'))}
-              disabled={isDisabled}
-            >
-              <Gamepad2 className="size-5 text-yellow-500" />
-              <div className="text-left">
-                <p className="font-medium">Play</p>
-                <p className="text-xs text-muted-foreground">
-                  Play with toys to make your Blobbi happy
-                </p>
-              </div>
-            </Button>
-          )}
-
-          {/* Clean Action - available for all stages */}
-          <Button
-            variant="outline"
-            className="w-full justify-start gap-3 h-14"
-            onClick={() => handleAction(() => onInventoryAction('clean'))}
-            disabled={isDisabled}
-          >
-            <SparklesIcon className="size-5 text-blue-500" />
-            <div className="text-left">
-              <p className="font-medium">Clean</p>
-              <p className="text-xs text-muted-foreground">
-                {isEgg 
-                  ? 'Keep your egg clean and fresh' 
-                  : 'Keep your Blobbi clean and fresh'}
-              </p>
-            </div>
-          </Button>
-
-          {/* Medicine Action - available for all stages */}
-          <Button
-            variant="outline"
-            className="w-full justify-start gap-3 h-14"
-            onClick={() => handleAction(() => onInventoryAction('medicine'))}
-            disabled={isDisabled}
-          >
-            <Pill className="size-5 text-green-500" />
-            <div className="text-left">
-              <p className="font-medium">Medicine</p>
-              <p className="text-xs text-muted-foreground">
-                {isEgg 
-                  ? 'Keep your egg healthy' 
-                  : 'Heal your Blobbi'}
-              </p>
-            </div>
-          </Button>
-
-          {/* Play Music Action - available for all stages */}
-          <Button
-            variant="outline"
-            className="w-full justify-start gap-3 h-14"
-            onClick={() => handleAction(() => onDirectAction('play_music'))}
-            disabled={isDisabled}
-          >
-            <Music className="size-5 text-pink-500" />
-            <div className="text-left">
-              <p className="font-medium">Play Music</p>
-              <p className="text-xs text-muted-foreground">
-                {isEgg 
-                  ? 'Play soothing music for your egg' 
-                  : 'Play music for your Blobbi'}
-              </p>
-            </div>
-          </Button>
-
-          {/* Sing Action - available for all stages */}
-          <Button
-            variant="outline"
-            className="w-full justify-start gap-3 h-14"
-            onClick={() => handleAction(() => onDirectAction('sing'))}
-            disabled={isDisabled}
-          >
-            <Mic className="size-5 text-purple-500" />
-            <div className="text-left">
-              <p className="font-medium">Sing</p>
-              <p className="text-xs text-muted-foreground">
-                {isEgg 
-                  ? 'Sing a lullaby to your egg' 
-                  : 'Sing to your Blobbi'}
-              </p>
-            </div>
-          </Button>
-
-          {/* Sleep/Wake Action - hidden for eggs */}
-          {!isEgg && (
-            <Button
-              variant="outline"
-              className="w-full justify-start gap-3 h-14"
-              onClick={() => handleAction(onRest)}
-              disabled={isDisabled}
-            >
-              {actionInProgress === 'rest' ? (
-                <Loader2 className="size-5 animate-spin" />
-              ) : isSleeping ? (
-                <Sun className="size-5 text-amber-500" />
-              ) : (
-                <Moon className="size-5 text-violet-500" />
-              )}
-              <div className="text-left">
-                <p className="font-medium">{isSleeping ? 'Wake Up' : 'Sleep'}</p>
-                <p className="text-xs text-muted-foreground">
-                  {isSleeping ? 'Wake your Blobbi up' : 'Put your Blobbi to sleep'}
-                </p>
-              </div>
-            </Button>
-          )}
-          </div>
-        </div>
-      </DialogContent>
-    </Dialog>
-  );
-}

src/blobbi/actions/components/BlobbiMissionsModal.tsx

@@ -1,538 +0,0 @@
-// src/blobbi/actions/components/BlobbiMissionsModal.tsx
-
-/**
- * Missions modal for Blobbi — card-grid quest board.
- *
- * Layout:
- * 1. Sticky header with title, subtitle, legend help button, close
- * 2. Current Focus section (hatch / evolve) — collapsible, default open
- * 3. Daily Bounties section — collapsible, default open
- * 4. Settings row — low emphasis toggle (not collapsible)
- *
- * Both main sections use lightweight Radix Collapsible wrappers.
- * Collapsed headers still show summary info (progress / coins).
- */
-
-import {
-  Loader2,
-  XCircle,
-  AlertTriangle,
-  X,
-  Eye,
-  Scroll,
-  Compass,
-  HelpCircle,
-  ChevronDown,
-} from 'lucide-react';
-import { cn } from '@/lib/utils';
-
-import { Button } from '@/components/ui/button';
-import { Switch } from '@/components/ui/switch';
-import { Label } from '@/components/ui/label';
-import { Badge } from '@/components/ui/badge';
-import { Dialog, DialogContent, DialogClose } from '@/components/ui/dialog';
-import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
-import { Collapsible, CollapsibleContent, CollapsibleTrigger } from '@/components/ui/collapsible';
-import {
-  AlertDialog,
-  AlertDialogAction,
-  AlertDialogCancel,
-  AlertDialogContent,
-  AlertDialogDescription,
-  AlertDialogFooter,
-  AlertDialogHeader,
-  AlertDialogTitle,
-} from '@/components/ui/alert-dialog';
-import { useState } from 'react';
-
-import type { BlobbiCompanion } from '@/blobbi/core/lib/blobbi';
-import type { HatchTasksResult } from '../hooks/useHatchTasks';
-import type { EvolveTasksResult } from '../hooks/useEvolveTasks';
-import { TasksPanel } from './TasksPanel';
-import { DailyMissionsPanel } from './DailyMissionsPanel';
-import { useDailyMissions } from '../hooks/useDailyMissions';
-import { useRerollMission } from '../hooks/useRerollMission';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-interface BlobbiMissionsModalProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  companion: BlobbiCompanion;
-  hatchTasks: HatchTasksResult;
-  evolveTasks: EvolveTasksResult;
-  onOpenPostModal: () => void;
-  onHatch: () => void;
-  isHatching: boolean;
-  onEvolve: () => void;
-  isEvolving: boolean;
-  onStopIncubation: () => Promise<void>;
-  isStoppingIncubation: boolean;
-  onStopEvolution: () => Promise<void>;
-  isStoppingEvolution: boolean;
-  availableStages?: ('egg' | 'baby' | 'adult')[];
-  showMissionCard?: boolean;
-  onToggleMissionCard?: (visible: boolean) => void;
-}
-
-// ─── Section Chevron ─────────────────────────────────────────────────────────
-
-function SectionChevron({ open }: { open: boolean }) {
-  return (
-    <ChevronDown
-      className={cn(
-        'size-4 text-muted-foreground/60 transition-transform duration-200',
-        open && 'rotate-180',
-      )}
-    />
-  );
-}
-
-// ─── Mission Type Legend ──────────────────────────────────────────────────────
-
-function MissionTypeLegend() {
-  return (
-    <Popover>
-      <PopoverTrigger asChild>
-        <button
-          type="button"
-          className="rounded-full p-1.5 opacity-50 hover:opacity-100 hover:bg-muted transition-all"
-          aria-label="Mission types legend"
-        >
-          <HelpCircle className="size-4" />
-        </button>
-      </PopoverTrigger>
-      <PopoverContent side="bottom" align="end" className="w-56 p-3">
-        <p className="text-xs font-semibold mb-2">Mission Types</p>
-        <div className="space-y-2">
-          <div className="flex items-center gap-2">
-            <div className="size-5 rounded-full bg-amber-500/15 flex items-center justify-center shrink-0">
-              <Scroll className="size-3 text-amber-500" />
-            </div>
-            <div>
-              <p className="text-xs font-medium">Daily Bounty</p>
-              <p className="text-[10px] text-muted-foreground">Resets every day</p>
-            </div>
-          </div>
-          <div className="flex items-center gap-2">
-            <div className="size-5 rounded-full bg-sky-500/15 flex items-center justify-center shrink-0">
-              <span className="text-xs">🥚</span>
-            </div>
-            <div>
-              <p className="text-xs font-medium">Hatch Task</p>
-              <p className="text-[10px] text-muted-foreground">Egg progression</p>
-            </div>
-          </div>
-          <div className="flex items-center gap-2">
-            <div className="size-5 rounded-full bg-violet-500/15 flex items-center justify-center shrink-0">
-              <span className="text-xs">🐣</span>
-            </div>
-            <div>
-              <p className="text-xs font-medium">Evolve Task</p>
-              <p className="text-[10px] text-muted-foreground">Baby progression</p>
-            </div>
-          </div>
-        </div>
-      </PopoverContent>
-    </Popover>
-  );
-}
-
-// ─── Daily Missions Section ───────────────────────────────────────────────────
-
-interface DailyMissionsSectionProps {
-  availableStages?: ('egg' | 'baby' | 'adult')[];
-  disabled?: boolean;
-  defaultOpen?: boolean;
-}
-
-function DailyMissionsSection({
-  availableStages,
-  disabled,
-  defaultOpen = true,
-}: DailyMissionsSectionProps) {
-  const [isOpen, setIsOpen] = useState(defaultOpen);
-
-  const {
-    missions,
-    todayXp,
-    allComplete,
-    bonusUnlocked,
-    bonusXp,
-    noMissionsAvailable,
-    rerollsRemaining,
-  } = useDailyMissions({ availableStages });
-
-  const { mutate: rerollMission, isPending: isRerolling } = useRerollMission();
-
-  const completedCount = missions.filter((m) => m.complete).length;
-
-  return (
-    <Collapsible open={isOpen} onOpenChange={setIsOpen}>
-      {/* Section header — tappable */}
-      <CollapsibleTrigger className="w-full">
-        <div className="flex items-center justify-between py-1 group">
-          <div className="flex items-center gap-2">
-            <Scroll className="size-4 text-amber-500 dark:text-amber-400 shrink-0" />
-            <h3 className="font-semibold text-sm">Daily Bounties</h3>
-          </div>
-          <div className="flex items-center gap-2">
-            {/* Summary pill — always visible */}
-            <div className="flex items-center gap-1.5 text-xs text-muted-foreground">
-              <span className="tabular-nums">
-                {completedCount} / {missions.length}
-              </span>
-              {allComplete && (
-                <span className="size-4 rounded-full bg-emerald-500 text-white text-[10px] font-bold flex items-center justify-center shrink-0">
-                  ✓
-                </span>
-              )}
-            </div>
-            <SectionChevron open={isOpen} />
-          </div>
-        </div>
-      </CollapsibleTrigger>
-
-      <CollapsibleContent className="overflow-hidden data-[state=open]:animate-collapsible-down data-[state=closed]:animate-collapsible-up">
-        <div className="pt-3">
-          <DailyMissionsPanel
-            missions={missions}
-            onRerollMission={(id) => rerollMission({ missionId: id, availableStages })}
-            todayXp={todayXp}
-            disabled={disabled || isRerolling}
-            bonusUnlocked={bonusUnlocked}
-            bonusXp={bonusXp}
-            noMissionsAvailable={noMissionsAvailable}
-            rerollsRemaining={rerollsRemaining}
-            isRerolling={isRerolling}
-          />
-        </div>
-      </CollapsibleContent>
-    </Collapsible>
-  );
-}
-
-// ─── Stop Process Confirmation Dialog ─────────────────────────────────────────
-
-interface StopConfirmationDialogProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  companionName: string;
-  processType: 'incubation' | 'evolution';
-  onConfirm: () => Promise<void>;
-  isPending: boolean;
-}
-
-function StopConfirmationDialog({
-  open,
-  onOpenChange,
-  companionName,
-  processType,
-  onConfirm,
-  isPending,
-}: StopConfirmationDialogProps) {
-  const handleConfirm = async () => {
-    await onConfirm();
-    onOpenChange(false);
-  };
-
-  const label = processType === 'incubation' ? 'Incubation' : 'Evolution';
-
-  return (
-    <AlertDialog open={open} onOpenChange={onOpenChange}>
-      <AlertDialogContent>
-        <AlertDialogHeader>
-          <AlertDialogTitle className="flex items-center gap-2">
-            <AlertTriangle className="size-5 text-amber-500" />
-            Stop {label}?
-          </AlertDialogTitle>
-          <AlertDialogDescription className="space-y-2">
-            <p>
-              Are you sure you want to stop {processType === 'incubation' ? 'incubating' : 'evolving'}{' '}
-              <strong>{companionName}</strong>?
-            </p>
-            <p>
-              This will interrupt the {processType} process and clear all task progress.
-              You can restart {processType} later, but you'll need to complete the tasks again.
-            </p>
-          </AlertDialogDescription>
-        </AlertDialogHeader>
-        <AlertDialogFooter>
-          <AlertDialogCancel disabled={isPending}>Cancel</AlertDialogCancel>
-          <AlertDialogAction
-            onClick={handleConfirm}
-            disabled={isPending}
-            className="bg-destructive hover:bg-destructive/90"
-          >
-            {isPending ? (
-              <>
-                <Loader2 className="size-4 mr-2 animate-spin" />
-                Stopping...
-              </>
-            ) : (
-              `Stop ${label}`
-            )}
-          </AlertDialogAction>
-        </AlertDialogFooter>
-      </AlertDialogContent>
-    </AlertDialog>
-  );
-}
-
-// ─── Current Focus Section (Hatch / Evolve) ──────────────────────────────────
-
-interface CurrentFocusSectionProps {
-  companion: BlobbiCompanion;
-  tasks: HatchTasksResult | EvolveTasksResult;
-  processType: 'incubation' | 'evolution';
-  onOpenPostModal: () => void;
-  onComplete: () => void;
-  isCompleting: boolean;
-  onStop: () => Promise<void>;
-  isStopping: boolean;
-  defaultOpen?: boolean;
-}
-
-function CurrentFocusSection({
-  companion,
-  tasks,
-  processType,
-  onOpenPostModal,
-  onComplete,
-  isCompleting,
-  onStop,
-  isStopping,
-  defaultOpen = true,
-}: CurrentFocusSectionProps) {
-  const [isOpen, setIsOpen] = useState(defaultOpen);
-  const [showStopConfirmation, setShowStopConfirmation] = useState(false);
-
-  const isIncubation = processType === 'incubation';
-  const title = isIncubation ? 'Hatch Tasks' : 'Evolve Tasks';
-  const completeLabel = isIncubation ? 'Hatch Your Blobbi!' : 'Evolve Your Blobbi!';
-  const completingLabel = isIncubation ? 'Hatching...' : 'Evolving...';
-  const completeEmoji = isIncubation ? '🐣' : '✨';
-  const stopLabel = isIncubation ? 'Stop Incubation' : 'Stop Evolution';
-  const badgeLabel = isIncubation ? 'Hatch' : 'Evolve';
-  const category = isIncubation ? ('hatch' as const) : ('evolve' as const);
-
-  const completedCount = tasks.tasks.filter((t) => t.completed).length;
-  const totalTasks = tasks.tasks.length;
-
-  return (
-    <Collapsible open={isOpen} onOpenChange={setIsOpen}>
-      {/* Section header — tappable */}
-      <CollapsibleTrigger className="w-full">
-        <div className="flex items-center justify-between py-1 group">
-          <div className="flex items-center gap-2">
-            <Badge
-              variant="secondary"
-              className={cn(
-                'text-xs font-semibold px-2 py-0.5',
-                isIncubation
-                  ? 'bg-sky-500/15 text-sky-600 dark:text-sky-400'
-                  : 'bg-violet-500/15 text-violet-600 dark:text-violet-400',
-              )}
-            >
-              {badgeLabel}
-            </Badge>
-            <span className="text-sm font-semibold">{title}</span>
-          </div>
-          <div className="flex items-center gap-2">
-            <span
-              className={cn(
-                'text-xs font-medium tabular-nums',
-                tasks.allCompleted
-                  ? 'text-emerald-600 dark:text-emerald-400'
-                  : 'text-muted-foreground',
-              )}
-            >
-              {completedCount} / {totalTasks}
-            </span>
-            <SectionChevron open={isOpen} />
-          </div>
-        </div>
-      </CollapsibleTrigger>
-
-      <CollapsibleContent className="overflow-hidden data-[state=open]:animate-collapsible-down data-[state=closed]:animate-collapsible-up">
-        <div className="pt-3">
-          {/* Task card grid */}
-          <TasksPanel
-            tasks={tasks.tasks}
-            allCompleted={tasks.allCompleted}
-            isLoading={tasks.isLoading}
-            onOpenPostModal={onOpenPostModal}
-            onComplete={onComplete}
-            isCompleting={isCompleting}
-            completeLabel={completeLabel}
-            completingLabel={completingLabel}
-            completeEmoji={completeEmoji}
-            category={category}
-          />
-
-          {/* Stop process — low emphasis */}
-          <div className="mt-3 flex justify-center">
-            <Button
-              variant="ghost"
-              size="sm"
-              onClick={() => setShowStopConfirmation(true)}
-              disabled={isStopping || isCompleting}
-              className="text-xs text-muted-foreground hover:text-destructive hover:bg-destructive/10 h-8 px-3"
-            >
-              {isStopping ? (
-                <>
-                  <Loader2 className="size-3.5 mr-1.5 animate-spin" />
-                  Stopping...
-                </>
-              ) : (
-                <>
-                  <XCircle className="size-3.5 mr-1.5" />
-                  {stopLabel}
-                </>
-              )}
-            </Button>
-          </div>
-        </div>
-      </CollapsibleContent>
-
-      <StopConfirmationDialog
-        open={showStopConfirmation}
-        onOpenChange={setShowStopConfirmation}
-        companionName={companion.name}
-        processType={processType}
-        onConfirm={onStop}
-        isPending={isStopping}
-      />
-    </Collapsible>
-  );
-}
-
-// ─── Empty Focus State ────────────────────────────────────────────────────────
-
-function EmptyFocusState() {
-  return (
-    <div className="py-6 text-center">
-      <Compass className="size-5 text-muted-foreground/50 mx-auto mb-2" />
-      <p className="text-sm text-muted-foreground">No active progression right now</p>
-    </div>
-  );
-}
-
-// ─── Main Modal ───────────────────────────────────────────────────────────────
-
-export function BlobbiMissionsModal({
-  open,
-  onOpenChange,
-  companion,
-  hatchTasks,
-  evolveTasks,
-  onOpenPostModal,
-  onHatch,
-  isHatching,
-  onEvolve,
-  isEvolving,
-  onStopIncubation,
-  isStoppingIncubation,
-  onStopEvolution,
-  isStoppingEvolution,
-  availableStages,
-  showMissionCard,
-  onToggleMissionCard,
-}: BlobbiMissionsModalProps) {
-  const isIncubating = companion.state === 'incubating';
-  const isEvolvingState = companion.state === 'evolving';
-  const isEgg = companion.stage === 'egg';
-  const isBaby = companion.stage === 'baby';
-
-  const hasActiveProcess = (isIncubating && isEgg) || (isEvolvingState && isBaby);
-  const isProcessBusy = isHatching || isEvolving || isStoppingIncubation || isStoppingEvolution;
-
-  return (
-    <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent className="max-w-lg w-[calc(100%-2rem)] max-h-[85vh] flex flex-col p-0 gap-0 overflow-hidden [&>button:last-child]:hidden">
-        {/* ── Sticky Header ── */}
-        <div className="sticky top-0 z-10 bg-background px-4 sm:px-5 pt-4 pb-3 border-b border-border/60">
-          <div className="flex items-center justify-between">
-            <div className="min-w-0">
-              <h2 className="text-base font-bold tracking-tight">Missions</h2>
-              <p className="text-xs text-muted-foreground mt-0.5">
-                Quests & bounties for {companion.name}
-              </p>
-            </div>
-            <div className="flex items-center gap-0.5 shrink-0">
-              <MissionTypeLegend />
-              <DialogClose className="rounded-full p-1.5 opacity-60 hover:opacity-100 hover:bg-muted transition-all">
-                <X className="size-4" />
-                <span className="sr-only">Close</span>
-              </DialogClose>
-            </div>
-          </div>
-        </div>
-
-        {/* ── Scrollable Content ── */}
-        <div className="flex-1 min-h-0 overflow-y-auto overflow-x-hidden px-4 sm:px-5 py-4 space-y-5">
-          {/* 1. Current Focus */}
-          {hasActiveProcess ? (
-            <>
-              {isIncubating && isEgg ? (
-                <CurrentFocusSection
-                  companion={companion}
-                  tasks={hatchTasks}
-                  processType="incubation"
-                  onOpenPostModal={onOpenPostModal}
-                  onComplete={onHatch}
-                  isCompleting={isHatching}
-                  onStop={onStopIncubation}
-                  isStopping={isStoppingIncubation}
-                />
-              ) : isEvolvingState && isBaby ? (
-                <CurrentFocusSection
-                  companion={companion}
-                  tasks={evolveTasks}
-                  processType="evolution"
-                  onOpenPostModal={onOpenPostModal}
-                  onComplete={onEvolve}
-                  isCompleting={isEvolving}
-                  onStop={onStopEvolution}
-                  isStopping={isStoppingEvolution}
-                />
-              ) : null}
-            </>
-          ) : (
-            <EmptyFocusState />
-          )}
-
-          {/* Divider */}
-          <div className="h-px bg-border/60" />
-
-          {/* 2. Daily Bounties */}
-          <DailyMissionsSection
-            availableStages={availableStages}
-            disabled={isProcessBusy}
-          />
-
-          {/* 3. Settings */}
-          {onToggleMissionCard !== undefined && showMissionCard !== undefined && (
-            <>
-              <div className="h-px bg-border/40" />
-              <div className="flex items-center justify-between py-1">
-                <Label
-                  htmlFor="mission-card-toggle"
-                  className="flex items-center gap-2 text-xs text-muted-foreground cursor-pointer"
-                >
-                  <Eye className="size-3.5" />
-                  Show mission card on main page
-                </Label>
-                <Switch
-                  id="mission-card-toggle"
-                  checked={showMissionCard}
-                  onCheckedChange={onToggleMissionCard}
-                />
-              </div>
-            </>
-          )}
-        </div>
-      </DialogContent>
-    </Dialog>
-  );
-}

src/blobbi/actions/components/BlobbiPostModal.tsx

@@ -1,294 +0,0 @@
-// src/blobbi/actions/components/BlobbiPostModal.tsx
-
-/**
- * Modal for creating a Blobbi post (hatch or evolve).
- * 
- * Requirements:
- * - Prefilled with stage-aware text:
- *   - Hatch: "Hello Nostr! Posting to hatch #<blobbiName> #blobbi #ditto #nostr"
- *   - Evolve: "Hello Nostr! Posting to evolve #<blobbiName> #blobbi #ditto #nostr"
- * - User can ADD text but CANNOT delete the prefix or required hashtags
- * - Blobbi name is sanitized into a valid hashtag format
- * - Enforced programmatically
- */
-
-import { useState, useCallback, useEffect, useMemo } from 'react';
-import { X, Loader2, AlertCircle } from 'lucide-react';
-
-import {
-  Dialog,
-  DialogContent,
-  DialogTitle,
-} from '@/components/ui/dialog';
-import { Button } from '@/components/ui/button';
-import { Textarea } from '@/components/ui/textarea';
-import { Alert, AlertDescription } from '@/components/ui/alert';
-
-import { useCurrentUser } from '@/hooks/useCurrentUser';
-import { useNostrPublish } from '@/hooks/useNostrPublish';
-import { toast } from '@/hooks/useToast';
-
-import {
-  BLOBBI_POST_REQUIRED_HASHTAGS,
-  buildHatchPhrase,
-} from '../hooks/useHatchTasks';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-/** The process type for the post */
-export type BlobbiPostProcess = 'hatch' | 'evolve';
-
-interface BlobbiPostModalProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  /** The Blobbi's name (will be converted to hashtag) */
-  blobbiName: string;
-  /** The process type - 'hatch' for incubation, 'evolve' for evolution */
-  process?: BlobbiPostProcess;
-  onSuccess?: () => void;
-}
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-/**
- * Build the required prefix text based on process type.
- */
-function buildPrefix(process: BlobbiPostProcess): string {
-  return process === 'evolve'
-    ? 'Posting to evolve'
-    : 'Posting to hatch';
-}
-
-// ─── Main Component ───────────────────────────────────────────────────────────
-
-export function BlobbiPostModal({
-  open,
-  onOpenChange,
-  blobbiName,
-  process = 'hatch',
-  onSuccess,
-}: BlobbiPostModalProps) {
-  const { user } = useCurrentUser();
-  const { mutateAsync: createEvent, isPending } = useNostrPublish();
-  
-  // Compute the required elements based on props
-  const prefix = useMemo(() => buildPrefix(process), [process]);
-  const capitalizedName = useMemo(() => blobbiName.charAt(0).toUpperCase() + blobbiName.slice(1), [blobbiName]);
-  
-  // The required phrase that must appear in the post
-  const requiredPhrase = useMemo(() => 
-    process === 'hatch'
-      ? buildHatchPhrase(blobbiName)
-      : `${prefix} ${capitalizedName} #blobbi`,
-    [process, blobbiName, prefix, capitalizedName]
-  );
-  
-  // Build default content (the phrase itself is enough)
-  const defaultContent = useMemo(() => requiredPhrase, [requiredPhrase]);
-  
-  const [content, setContent] = useState(defaultContent);
-  const [validationError, setValidationError] = useState<string | null>(null);
-  
-  // Reset content when modal opens or props change
-  useEffect(() => {
-    if (open) {
-      setContent(defaultContent);
-      setValidationError(null);
-    }
-  }, [open, defaultContent]);
-  
-  /**
-   * Validate that the content contains the required phrase.
-   */
-  const validateContent = useCallback((text: string): string | null => {
-    if (!text.includes(requiredPhrase)) {
-      return `The post must contain: "${requiredPhrase}"`;
-    }
-    return null;
-  }, [requiredPhrase]);
-  
-  /**
-   * Handle content change with validation.
-   * Prevents deletion of required content.
-   */
-  const handleContentChange = useCallback((e: React.ChangeEvent<HTMLTextAreaElement>) => {
-    const newContent = e.target.value;
-    
-    // Allow content changes only if it preserves the required elements
-    const error = validateContent(newContent);
-    
-    if (error) {
-      setValidationError(error);
-      // Still update content but show error
-      // This allows the user to see what they're trying to do
-      // but the post button will be disabled
-    } else {
-      setValidationError(null);
-    }
-    
-    setContent(newContent);
-  }, [validateContent]);
-  
-  /**
-   * Handle post creation.
-   */
-  const handlePost = useCallback(async () => {
-    if (!user?.pubkey) {
-      toast({
-        title: 'Not logged in',
-        description: 'Please log in to create a post',
-        variant: 'destructive',
-      });
-      return;
-    }
-    
-    // Final validation
-    const error = validateContent(content);
-    if (error) {
-      setValidationError(error);
-      return;
-    }
-    
-    try {
-      // Build tags for the post: extract all hashtags from content
-      const tags: string[][] = [];
-      const seen = new Set<string>();
-      
-      // Always include BLOBBI_POST_REQUIRED_HASHTAGS as t tags
-      for (const hashtag of BLOBBI_POST_REQUIRED_HASHTAGS) {
-        const lower = hashtag.toLowerCase();
-        if (!seen.has(lower)) {
-          tags.push(['t', lower]);
-          seen.add(lower);
-        }
-      }
-      
-      // Extract any additional hashtags from the content
-      const contentHashtags = content.match(/#(\w+)/g) || [];
-      for (const tag of contentHashtags) {
-        const tagValue = tag.slice(1).toLowerCase();
-        if (!seen.has(tagValue)) {
-          tags.push(['t', tagValue]);
-          seen.add(tagValue);
-        }
-      }
-      
-      await createEvent({
-        kind: 1,
-        content,
-        tags,
-      });
-      
-      toast({
-        title: 'Post created!',
-        description: process === 'evolve' 
-          ? 'Your Blobbi evolution post has been published.'
-          : 'Your Blobbi hatch post has been published.',
-      });
-      
-      onOpenChange(false);
-      onSuccess?.();
-    } catch (error) {
-      toast({
-        title: 'Failed to create post',
-        description: error instanceof Error ? error.message : 'Unknown error',
-        variant: 'destructive',
-      });
-    }
-  }, [user, content, validateContent, createEvent, onOpenChange, onSuccess, process]);
-  
-  const canPost = !validationError && content.trim().length > 0;
-  
-  const dialogTitle = process === 'evolve' ? 'Blobbi Evolution Post' : 'Blobbi Hatch Post';
-  const alertText = process === 'evolve'
-    ? "This special post announces your Blobbi's evolution! The highlighted text must remain in your post."
-    : "This special post announces your Blobbi's hatching journey! The highlighted text must remain in your post.";
-  
-  return (
-    <Dialog open={open} onOpenChange={onOpenChange}>
-      <DialogContent className="max-w-lg p-0 gap-0">
-        {/* Header */}
-        <div className="flex items-center justify-between px-4 h-14 border-b">
-          <DialogTitle className="text-base font-semibold">
-            {dialogTitle}
-          </DialogTitle>
-          <button
-            onClick={() => onOpenChange(false)}
-            className="p-1.5 -mr-1.5 rounded-full text-muted-foreground hover:text-foreground hover:bg-secondary/60 transition-colors"
-          >
-            <X className="size-5" />
-          </button>
-        </div>
-        
-        {/* Content */}
-        <div className="p-4 space-y-4">
-          {/* Info alert */}
-          <Alert className="border-primary/20 bg-primary/5">
-            <AlertDescription className="text-sm">
-              {alertText}
-            </AlertDescription>
-          </Alert>
-          
-          {/* Textarea */}
-          <div className="space-y-2">
-            <Textarea
-              value={content}
-              onChange={handleContentChange}
-              placeholder="Write your post..."
-              className="min-h-[150px] resize-none"
-              disabled={isPending}
-            />
-            
-            {/* Character count and validation */}
-            <div className="flex items-center justify-between text-sm">
-              <div>
-                {validationError && (
-                  <span className="text-destructive flex items-center gap-1">
-                    <AlertCircle className="size-3.5" />
-                    {validationError}
-                  </span>
-                )}
-              </div>
-              <span className="text-muted-foreground">
-                {content.length} characters
-              </span>
-            </div>
-          </div>
-          
-          {/* Preview of required content */}
-          <div className="p-3 rounded-lg bg-muted/50 border border-dashed">
-            <p className="text-xs text-muted-foreground mb-1">Required phrase:</p>
-            <p className="text-sm font-medium text-primary">
-              {requiredPhrase}
-            </p>
-          </div>
-        </div>
-        
-        {/* Footer */}
-        <div className="flex items-center justify-end gap-2 px-4 py-3 border-t bg-muted/30">
-          <Button
-            variant="outline"
-            onClick={() => onOpenChange(false)}
-            disabled={isPending}
-          >
-            Cancel
-          </Button>
-          <Button
-            onClick={handlePost}
-            disabled={!canPost || isPending}
-            className="min-w-24"
-          >
-            {isPending ? (
-              <>
-                <Loader2 className="size-4 mr-2 animate-spin" />
-                Posting...
-              </>
-            ) : (
-              'Post'
-            )}
-          </Button>
-        </div>
-      </DialogContent>
-    </Dialog>
-  );
-}

src/blobbi/actions/components/DailyMissionsPanel.tsx

@@ -1,284 +0,0 @@
-/**
- * DailyMissionsPanel — card-grid layout for daily bounties.
- *
- * Each mission is a compact card in a 2-col grid.
- * Tapping a card expands it to show progress and reroll.
- * Only one card expanded at a time.
- * Completion is implicit (derived from progress vs target).
- */
-
-import { useState } from 'react';
-import {
-  Check,
-  Sparkles,
-  Gift,
-  Egg,
-  Trophy,
-  RefreshCw,
-  Heart,
-  Utensils,
-  Droplets,
-  Moon,
-  Camera,
-  Mic,
-  Music,
-  Pill,
-  CircleDot,
-  Zap,
-} from 'lucide-react';
-
-import { Tooltip, TooltipContent, TooltipProvider, TooltipTrigger } from '@/components/ui/tooltip';
-import { cn, formatCompactNumber } from '@/lib/utils';
-import type { DailyMissionAction } from '../lib/daily-missions';
-import type { DailyMissionView } from '../hooks/useDailyMissions';
-import {
-  ExpandableMissionCard,
-  MissionDescription,
-  MissionProgress,
-} from './ExpandableMissionCard';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-interface DailyMissionsPanelProps {
-  missions: DailyMissionView[];
-  onRerollMission?: (missionId: string) => void;
-  todayXp: number;
-  disabled?: boolean;
-  bonusUnlocked?: boolean;
-  bonusXp?: number;
-  noMissionsAvailable?: boolean;
-  rerollsRemaining?: number;
-  isRerolling?: boolean;
-}
-
-// ─── Daily Mission Icon Mapping ───────────────────────────────────────────────
-
-function DailyMissionIcon({ action }: { action: DailyMissionAction }) {
-  const cls = 'size-5';
-  switch (action) {
-    case 'interact':
-      return <Heart className={cls} />;
-    case 'feed':
-      return <Utensils className={cls} />;
-    case 'clean':
-      return <Droplets className={cls} />;
-    case 'sleep':
-      return <Moon className={cls} />;
-    case 'take_photo':
-      return <Camera className={cls} />;
-    case 'sing':
-      return <Mic className={cls} />;
-    case 'play_music':
-      return <Music className={cls} />;
-    case 'medicine':
-      return <Pill className={cls} />;
-    default:
-      return <CircleDot className={cls} />;
-  }
-}
-
-// ─── Bonus Card ───────────────────────────────────────────────────────────────
-
-interface BonusCardProps {
-  isUnlocked: boolean;
-  xp: number;
-  isExpanded: boolean;
-  onToggle: (id: string) => void;
-}
-
-function BonusCard({ isUnlocked, xp, isExpanded, onToggle }: BonusCardProps) {
-  return (
-    <ExpandableMissionCard
-      id="bonus"
-      category="daily"
-      icon={<Trophy className="size-5" />}
-      title="Daily Champion"
-      completed={isUnlocked}
-      progress={isUnlocked ? 1 : 0}
-      isExpanded={isExpanded}
-      onToggle={onToggle}
-    >
-      <MissionDescription>
-        {isUnlocked
-          ? 'Bonus XP for completing all daily missions!'
-          : 'Complete all missions to unlock this bonus'}
-      </MissionDescription>
-
-      <div className="flex items-center gap-1 text-xs font-medium text-violet-600 dark:text-violet-400">
-        <Zap className="size-3" />
-        +{formatCompactNumber(xp)} XP
-      </div>
-    </ExpandableMissionCard>
-  );
-}
-
-// ─── Empty / Done States ──────────────────────────────────────────────────────
-
-function NoMissionsState() {
-  return (
-    <div className="flex flex-col items-center gap-2 py-6 text-center">
-      <Egg className="size-5 text-muted-foreground/50" />
-      <div>
-        <p className="text-sm font-medium">Hatch your Blobbi first</p>
-        <p className="text-xs text-muted-foreground mt-0.5">
-          Daily missions unlock after hatching
-        </p>
-      </div>
-    </div>
-  );
-}
-
-function AllCompleteState({ todayXp }: { todayXp: number }) {
-  return (
-    <div className="flex flex-col items-center gap-2 py-6 text-center">
-      <Sparkles className="size-5 text-primary/60" />
-      <div>
-        <p className="text-sm font-medium">All done for today</p>
-        <p className="text-xs text-muted-foreground mt-0.5">
-          Earned{' '}
-          <span className="font-medium text-violet-600 dark:text-violet-400">
-            {formatCompactNumber(todayXp)} XP
-          </span>{' '}
-          — come back tomorrow!
-        </p>
-      </div>
-    </div>
-  );
-}
-
-// ─── Reroll Counter ───────────────────────────────────────────────────────────
-
-function RerollCounter({ remaining }: { remaining: number }) {
-  const text =
-    remaining === 0
-      ? 'No rerolls left'
-      : remaining === 1
-        ? '1 reroll left'
-        : `${remaining} rerolls left`;
-
-  return (
-    <div className="flex items-center justify-end gap-1 text-[11px] text-muted-foreground col-span-full">
-      <RefreshCw className="size-2.5" />
-      <span>{text}</span>
-    </div>
-  );
-}
-
-// ─── Main Component ───────────────────────────────────────────────────────────
-
-export function DailyMissionsPanel({
-  missions,
-  onRerollMission,
-  todayXp,
-  disabled,
-  bonusUnlocked = false,
-  bonusXp = 50,
-  noMissionsAvailable = false,
-  rerollsRemaining = 0,
-  isRerolling = false,
-}: DailyMissionsPanelProps) {
-  const [expandedId, setExpandedId] = useState<string | null>(null);
-
-  if (noMissionsAvailable) return <NoMissionsState />;
-
-  const allComplete = missions.every((m) => m.complete);
-  if (allComplete && bonusUnlocked) return <AllCompleteState todayXp={todayXp} />;
-
-  const canReroll = rerollsRemaining > 0 && !!onRerollMission;
-
-  const handleToggle = (id: string) => {
-    setExpandedId((prev) => (prev === id ? null : id));
-  };
-
-  return (
-    <div className="grid grid-cols-2 sm:grid-cols-3 gap-2">
-      {/* Reroll counter */}
-      {onRerollMission && <RerollCounter remaining={rerollsRemaining} />}
-
-      {/* Regular mission cards */}
-      {missions.map((mission) => {
-        const progressFrac = mission.target > 0 ? mission.progress / mission.target : 0;
-        const showReroll = onRerollMission && !mission.complete && canReroll;
-
-        return (
-          <ExpandableMissionCard
-            key={mission.id}
-            id={mission.id}
-            category="daily"
-            icon={<DailyMissionIcon action={mission.action} />}
-            title={mission.title}
-            completed={mission.complete}
-            progress={Math.min(progressFrac, 1)}
-            isExpanded={expandedId === mission.id}
-            onToggle={handleToggle}
-          >
-            {/* Description */}
-            <MissionDescription>{mission.description}</MissionDescription>
-
-            {/* Progress */}
-            {!mission.complete && (
-              <MissionProgress
-                current={mission.progress}
-                required={mission.target}
-                completed={mission.complete}
-              />
-            )}
-
-            {/* XP + reroll row */}
-            <div className="flex items-center justify-between">
-              <span className="inline-flex items-center gap-0.5 text-xs font-medium text-violet-600 dark:text-violet-400">
-                <Zap className="size-3" />
-                {formatCompactNumber(mission.xp)} XP
-              </span>
-
-              {showReroll && (
-                <TooltipProvider>
-                  <Tooltip>
-                    <TooltipTrigger asChild>
-                      <button
-                        onClick={(e) => {
-                          e.stopPropagation();
-                          onRerollMission(mission.id);
-                        }}
-                        disabled={disabled || isRerolling}
-                        className="p-1 rounded-md text-muted-foreground hover:text-foreground hover:bg-muted transition-colors disabled:opacity-40"
-                      >
-                        <RefreshCw className={cn('size-3', isRerolling && 'animate-spin')} />
-                      </button>
-                    </TooltipTrigger>
-                    <TooltipContent side="left">
-                      <p>Replace mission</p>
-                    </TooltipContent>
-                  </Tooltip>
-                </TooltipProvider>
-              )}
-
-              {mission.complete && (
-                <span className="inline-flex items-center gap-0.5 text-[10px] font-medium text-primary">
-                  <Check className="size-2.5" />
-                  Done
-                </span>
-              )}
-            </div>
-
-            {/* Complete indicator */}
-            {mission.complete && (
-              <div className="flex items-center gap-1 text-xs text-emerald-600 dark:text-emerald-400">
-                <Gift className="size-3.5" />
-                +{formatCompactNumber(mission.xp)} XP earned
-              </div>
-            )}
-          </ExpandableMissionCard>
-        );
-      })}
-
-      {/* Bonus card */}
-      <BonusCard
-        isUnlocked={bonusUnlocked}
-        xp={bonusXp}
-        isExpanded={expandedId === 'bonus'}
-        onToggle={handleToggle}
-      />
-    </div>
-  );
-}

src/blobbi/actions/components/ExpandableMissionCard.tsx

@@ -1,250 +0,0 @@
-// src/blobbi/actions/components/ExpandableMissionCard.tsx
-
-/**
- * Expandable mission card for the quest-board grid.
- *
- * Collapsed: compact square-ish card showing icon, title, and a tiny
- *            progress ring / checkmark.
- * Expanded:  full-width row that reveals description, progress bar,
- *            action link, claim button, dynamic hints, etc.
- *
- * Only one card is expanded at a time per section (controlled by parent).
- */
-
-import type { ReactNode } from 'react';
-import { Check, ChevronRight, ExternalLink, AlertCircle } from 'lucide-react';
-import { Progress } from '@/components/ui/progress';
-import { cn } from '@/lib/utils';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-export type MissionCategory = 'daily' | 'hatch' | 'evolve';
-
-export interface ExpandableMissionCardProps {
-  /** Unique id used to track which card is expanded */
-  id: string;
-  /** Mission category for visual styling */
-  category: MissionCategory;
-  /** Icon rendered in the compact card (ReactNode — usually a lucide icon or emoji span) */
-  icon: ReactNode;
-  /** Short title */
-  title: string;
-  /** Whether the mission is complete */
-  completed: boolean;
-  /** Progress fraction 0-1 (used for the tiny ring in compact mode) */
-  progress: number;
-  /** Whether this card is currently expanded */
-  isExpanded: boolean;
-  /** Parent calls this to toggle expansion */
-  onToggle: (id: string) => void;
-  /** Content rendered only when expanded */
-  children: ReactNode;
-  /** Optional extra className on the outer wrapper */
-  className?: string;
-}
-
-// ─── Tiny Progress Ring ───────────────────────────────────────────────────────
-
-function ProgressRing({ progress, completed, category }: { progress: number; completed: boolean; category: MissionCategory }) {
-  const size = 28;
-  const stroke = 2.5;
-  const radius = (size - stroke) / 2;
-  const circumference = 2 * Math.PI * radius;
-  const offset = circumference - progress * circumference;
-
-  if (completed) {
-    return (
-      <div className="size-7 rounded-full bg-emerald-500/20 flex items-center justify-center">
-        <Check className="size-3.5 text-emerald-600 dark:text-emerald-400" />
-      </div>
-    );
-  }
-
-  const ringColor =
-    category === 'hatch'
-      ? 'text-sky-500'
-      : category === 'evolve'
-        ? 'text-violet-500'
-        : 'text-amber-500';
-
-  return (
-    <svg width={size} height={size} className={cn('shrink-0 -rotate-90', ringColor)}>
-      <circle
-        cx={size / 2}
-        cy={size / 2}
-        r={radius}
-        fill="none"
-        stroke="currentColor"
-        strokeWidth={stroke}
-        opacity={0.15}
-      />
-      <circle
-        cx={size / 2}
-        cy={size / 2}
-        r={radius}
-        fill="none"
-        stroke="currentColor"
-        strokeWidth={stroke}
-        strokeDasharray={circumference}
-        strokeDashoffset={offset}
-        strokeLinecap="round"
-        className="transition-all duration-300"
-      />
-    </svg>
-  );
-}
-
-// ─── Accent colors per category ───────────────────────────────────────────────
-
-const CATEGORY_STYLES: Record<MissionCategory, { bg: string; expandedBg: string; border: string }> = {
-  daily: {
-    bg: 'bg-amber-500/[0.06] hover:bg-amber-500/10',
-    expandedBg: 'bg-amber-500/[0.06]',
-    border: 'ring-amber-500/20',
-  },
-  hatch: {
-    bg: 'bg-sky-500/[0.06] hover:bg-sky-500/10',
-    expandedBg: 'bg-sky-500/[0.06]',
-    border: 'ring-sky-500/20',
-  },
-  evolve: {
-    bg: 'bg-violet-500/[0.06] hover:bg-violet-500/10',
-    expandedBg: 'bg-violet-500/[0.06]',
-    border: 'ring-violet-500/20',
-  },
-};
-
-// ─── Component ────────────────────────────────────────────────────────────────
-
-export function ExpandableMissionCard({
-  id,
-  category,
-  icon,
-  title,
-  completed,
-  progress,
-  isExpanded,
-  onToggle,
-  children,
-  className,
-}: ExpandableMissionCardProps) {
-  const styles = CATEGORY_STYLES[category];
-
-  // ── Collapsed card ──
-  if (!isExpanded) {
-    return (
-      <button
-        type="button"
-        onClick={() => onToggle(id)}
-        className={cn(
-          'flex flex-col items-center gap-1.5 rounded-xl p-3 transition-all text-center cursor-pointer select-none',
-          'ring-1 ring-transparent',
-          completed ? 'bg-emerald-500/[0.06] hover:bg-emerald-500/10' : styles.bg,
-          className,
-        )}
-      >
-        {/* Icon */}
-        <div className="text-lg leading-none">{icon}</div>
-
-        {/* Title — 2 lines max */}
-        <span className={cn(
-          'text-[11px] font-medium leading-tight line-clamp-2 min-h-[2lh]',
-          completed && 'text-emerald-600 dark:text-emerald-400',
-        )}>
-          {title}
-        </span>
-
-        {/* Progress ring / check */}
-        <ProgressRing progress={progress} completed={completed} category={category} />
-      </button>
-    );
-  }
-
-  // ── Expanded card (spans full row) ──
-  return (
-    <div
-      className={cn(
-        'col-span-full rounded-xl ring-1 transition-all overflow-hidden',
-        completed ? 'bg-emerald-500/[0.06] ring-emerald-500/20' : cn(styles.expandedBg, styles.border),
-        className,
-      )}
-    >
-      {/* Compact header — click to collapse */}
-      <button
-        type="button"
-        onClick={() => onToggle(id)}
-        className="w-full flex items-center gap-3 p-3 text-left cursor-pointer select-none"
-      >
-        <div className="text-lg leading-none shrink-0">{icon}</div>
-        <span className={cn(
-          'text-sm font-medium flex-1 min-w-0',
-          completed && 'text-emerald-600 dark:text-emerald-400',
-        )}>
-          {title}
-        </span>
-        <ProgressRing progress={progress} completed={completed} category={category} />
-      </button>
-
-      {/* Expanded details */}
-      <div className="px-3 pb-3 pt-0 space-y-2">
-        {children}
-      </div>
-    </div>
-  );
-}
-
-// ─── Shared detail sub-components ─────────────────────────────────────────────
-
-/** Description text */
-export function MissionDescription({ children }: { children: ReactNode }) {
-  return <p className="text-xs text-muted-foreground leading-snug">{children}</p>;
-}
-
-/** Progress bar with fraction label */
-export function MissionProgress({ current, required, completed }: { current: number; required: number; completed: boolean }) {
-  const pct = required > 0 ? Math.round((current / required) * 100) : 0;
-  return (
-    <div>
-      <div className="flex items-center justify-between text-[11px] text-muted-foreground mb-1">
-        <span className="tabular-nums">{current} / {required}</span>
-        <span className="tabular-nums">{pct}%</span>
-      </div>
-      <Progress value={pct} className={cn('h-1.5', completed && '[&>div]:bg-emerald-500')} />
-    </div>
-  );
-}
-
-/** Inline action link (navigate, external, modal) */
-export function MissionAction({
-  label,
-  type,
-  onClick,
-}: {
-  label: string;
-  type: 'navigate' | 'external_link' | 'open_modal';
-  onClick: () => void;
-}) {
-  return (
-    <button
-      onClick={onClick}
-      className="inline-flex items-center gap-1 text-xs font-medium text-primary hover:underline"
-    >
-      {label}
-      {type === 'external_link' ? (
-        <ExternalLink className="size-3" />
-      ) : (
-        <ChevronRight className="size-3" />
-      )}
-    </button>
-  );
-}
-
-/** Dynamic / live task hint */
-export function DynamicHint({ current, required }: { current: number; required: number }) {
-  return (
-    <div className="flex items-center gap-1.5 text-[11px] text-amber-600/80 dark:text-amber-400/80">
-      <AlertCircle className="size-3 shrink-0" />
-      <span>Lowest stat: {current}% (need {required}%+)</span>
-    </div>
-  );
-}

src/blobbi/actions/components/HatchTasksPanel.tsx

@@ -1,221 +0,0 @@
-// src/blobbi/actions/components/HatchTasksPanel.tsx
-
-/**
- * UI component for displaying hatch task progress.
- * Shows a list of tasks with progress indicators and action buttons.
- */
-
-import { ExternalLink, Check, Loader2, ChevronRight } from 'lucide-react';
-import { useNavigate } from 'react-router-dom';
-import { openUrl } from '@/lib/downloadFile';
-
-import { Button } from '@/components/ui/button';
-import { Progress } from '@/components/ui/progress';
-import { Card, CardContent, CardHeader, CardTitle, CardDescription } from '@/components/ui/card';
-import { Badge } from '@/components/ui/badge';
-import { cn } from '@/lib/utils';
-
-import type { HatchTask } from '../hooks/useHatchTasks';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-interface HatchTasksPanelProps {
-  tasks: HatchTask[];
-  allCompleted: boolean;
-  isLoading: boolean;
-  /** Called when user clicks "Create Post" action */
-  onOpenPostModal: () => void;
-  /** Called when all tasks are complete and user clicks "Hatch" */
-  onHatch: () => void;
-  /** Whether hatching is in progress */
-  isHatching?: boolean;
-}
-
-// ─── Task Row Component ───────────────────────────────────────────────────────
-
-interface TaskRowProps {
-  task: HatchTask;
-  onOpenPostModal: () => void;
-}
-
-function TaskRow({ task, onOpenPostModal }: TaskRowProps) {
-  const navigate = useNavigate();
-  
-  const handleAction = () => {
-    if (!task.action || !task.actionTarget) return;
-    
-    switch (task.action) {
-      case 'navigate':
-        navigate(task.actionTarget);
-        break;
-      case 'external_link':
-        openUrl(task.actionTarget);
-        break;
-      case 'open_modal':
-        if (task.actionTarget === 'blobbi_post') {
-          onOpenPostModal();
-        }
-        break;
-    }
-  };
-  
-  const progress = task.required > 1 
-    ? Math.round((task.current / task.required) * 100)
-    : task.completed ? 100 : 0;
-  
-  return (
-    <div
-      className={cn(
-        "flex items-center gap-4 p-4 rounded-xl border transition-all",
-        task.completed 
-          ? "bg-emerald-500/5 border-emerald-500/20" 
-          : "bg-card/60 border-border hover:border-primary/30"
-      )}
-    >
-      {/* Status indicator */}
-      <div className={cn(
-        "size-10 rounded-full flex items-center justify-center shrink-0",
-        task.completed 
-          ? "bg-emerald-500/20 text-emerald-600 dark:text-emerald-400"
-          : "bg-muted text-muted-foreground"
-      )}>
-        {task.completed ? (
-          <Check className="size-5" />
-        ) : task.required > 1 ? (
-          <span className="text-sm font-medium">{task.current}/{task.required}</span>
-        ) : (
-          <span className="text-lg">○</span>
-        )}
-      </div>
-      
-      {/* Task info */}
-      <div className="flex-1 min-w-0">
-        <div className="flex items-center gap-2 mb-1">
-          <h4 className={cn(
-            "font-medium",
-            task.completed && "text-emerald-600 dark:text-emerald-400"
-          )}>
-            {task.name}
-          </h4>
-          {task.completed && (
-            <Badge variant="secondary" className="bg-emerald-500/20 text-emerald-700 dark:text-emerald-300 text-xs">
-              Complete
-            </Badge>
-          )}
-        </div>
-        <p className="text-sm text-muted-foreground">
-          {task.description}
-        </p>
-        
-        {/* Progress bar for multi-step tasks */}
-        {task.required > 1 && !task.completed && (
-          <Progress value={progress} className="h-1.5 mt-2" />
-        )}
-      </div>
-      
-      {/* Action button */}
-      {task.action && task.actionLabel && !task.completed && (
-        <Button
-          variant="outline"
-          size="sm"
-          onClick={handleAction}
-          className="shrink-0 gap-2"
-        >
-          {task.actionLabel}
-          {task.action === 'external_link' ? (
-            <ExternalLink className="size-3.5" />
-          ) : (
-            <ChevronRight className="size-3.5" />
-          )}
-        </Button>
-      )}
-    </div>
-  );
-}
-
-// ─── Main Component ───────────────────────────────────────────────────────────
-
-export function HatchTasksPanel({
-  tasks,
-  allCompleted,
-  isLoading,
-  onOpenPostModal,
-  onHatch,
-  isHatching = false,
-}: HatchTasksPanelProps) {
-  const completedCount = tasks.filter(t => t.completed).length;
-  const totalTasks = tasks.length;
-  const overallProgress = Math.round((completedCount / totalTasks) * 100);
-  
-  return (
-    <Card className="border-primary/20 bg-gradient-to-br from-primary/5 to-transparent">
-      <CardHeader className="pb-4">
-        <div className="flex items-center justify-between">
-          <div>
-            <CardTitle className="flex items-center gap-2">
-              <span className="text-2xl">🥚</span>
-              Hatch Tasks
-            </CardTitle>
-            <CardDescription>
-              Complete these tasks to hatch your Blobbi
-            </CardDescription>
-          </div>
-          <Badge variant="outline" className="text-base px-3 py-1">
-            {completedCount}/{totalTasks}
-          </Badge>
-        </div>
-        
-        {/* Overall progress */}
-        <div className="mt-4">
-          <div className="flex items-center justify-between text-sm mb-2">
-            <span className="text-muted-foreground">Overall progress</span>
-            <span className="font-medium">{overallProgress}%</span>
-          </div>
-          <Progress value={overallProgress} className="h-2" />
-        </div>
-      </CardHeader>
-      
-      <CardContent className="space-y-3">
-        {isLoading ? (
-          <div className="flex items-center justify-center py-8">
-            <Loader2 className="size-6 animate-spin text-muted-foreground" />
-          </div>
-        ) : (
-          <>
-            {tasks.map(task => (
-              <TaskRow 
-                key={task.id} 
-                task={task} 
-                onOpenPostModal={onOpenPostModal}
-              />
-            ))}
-            
-            {/* Hatch button - only visible when all tasks complete */}
-            {allCompleted && (
-              <div className="pt-4 border-t border-border mt-4">
-                <Button
-                  onClick={onHatch}
-                  disabled={isHatching}
-                  size="lg"
-                  className="w-full gap-2 bg-gradient-to-r from-amber-500 to-orange-500 hover:from-amber-600 hover:to-orange-600 text-white"
-                >
-                  {isHatching ? (
-                    <>
-                      <Loader2 className="size-5 animate-spin" />
-                      Hatching...
-                    </>
-                  ) : (
-                    <>
-                      <span className="text-xl">🐣</span>
-                      Hatch Your Blobbi!
-                    </>
-                  )}
-                </Button>
-              </div>
-            )}
-          </>
-        )}
-      </CardContent>
-    </Card>
-  );
-}

src/blobbi/actions/components/InlineMusicPlayer.tsx

@@ -1,251 +0,0 @@
-// src/blobbi/actions/components/InlineMusicPlayer.tsx
-
-import { useCallback, useEffect } from 'react';
-import { Music, Play, Pause, RotateCcw, MoreHorizontal, Loader2, AlertCircle, X, Volume2, VolumeX } from 'lucide-react';
-
-import { Button } from '@/components/ui/button';
-import { Slider } from '@/components/ui/slider';
-import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
-import { cn } from '@/lib/utils';
-
-import { useAudioPlayback } from '../hooks/useAudioPlayback';
-import type { SelectedTrack } from './PlayMusicModal';
-
-// Re-export for external use
-export type { SelectedTrack } from './PlayMusicModal';
-
-interface InlineMusicPlayerProps {
-  /** The selected track */
-  selection: SelectedTrack;
-  /** Called when user wants to change the track */
-  onChangeTrack: () => void;
-  /** Called when user closes the player */
-  onClose: () => void;
-  /** Called when playback starts (for Blobbi reaction state) */
-  onPlaybackStart?: () => void;
-  /** Called when playback stops/pauses (for Blobbi reaction state) */
-  onPlaybackStop?: () => void;
-  /** Whether the action has been published (playback only starts after publish) */
-  isPublished: boolean;
-  /** Whether publishing is in progress */
-  isPublishing: boolean;
-}
-
-// ─── Component ────────────────────────────────────────────────────────────────
-
-export function InlineMusicPlayer({
-  selection,
-  onChangeTrack,
-  onClose,
-  onPlaybackStart,
-  onPlaybackStop,
-  isPublished,
-  isPublishing,
-}: InlineMusicPlayerProps) {
-  const {
-    state: playbackState,
-    error: playbackError,
-    load,
-    toggle,
-    restart,
-    stop,
-    isPlaying,
-    volume,
-    setVolume,
-    cleanup,
-  } = useAudioPlayback({
-    onEnded: () => {
-      onPlaybackStop?.();
-    },
-  });
-  
-  // Auto-start playback when first published (idle -> playing)
-  // Note: 'stopped' state is NOT included here - stop is a terminal state
-  // that requires explicit user action (play button) to restart
-  useEffect(() => {
-    if (isPublished && playbackState === 'idle') {
-      load(selection.url, true);
-      onPlaybackStart?.();
-    }
-  }, [isPublished, playbackState, selection.url, load, onPlaybackStart]);
-  
-  // Force reload when source URL changes while already playing/paused
-  useEffect(() => {
-    // Only trigger reload if we're in an active playback state with a different URL
-    if (isPublished && (playbackState === 'playing' || playbackState === 'paused')) {
-      // The load function will check if URL changed and reload if needed
-      load(selection.url, true);
-    }
-    // eslint-disable-next-line react-hooks/exhaustive-deps -- Only react to selection.url changes
-  }, [selection.url]);
-  
-  // Notify on playback state changes
-  useEffect(() => {
-    if (isPlaying) {
-      onPlaybackStart?.();
-    } else if (playbackState === 'paused' || playbackState === 'stopped') {
-      onPlaybackStop?.();
-    }
-  }, [isPlaying, playbackState, onPlaybackStart, onPlaybackStop]);
-  
-  // Cleanup on close
-  const handleClose = useCallback(() => {
-    stop();
-    cleanup();
-    onPlaybackStop?.();
-    onClose();
-  }, [stop, cleanup, onPlaybackStop, onClose]);
-  
-  // Handle play/pause toggle
-  const handleToggle = useCallback(async () => {
-    if (playbackState === 'idle' || playbackState === 'stopped') {
-      load(selection.url, true);
-    } else {
-      await toggle();
-    }
-  }, [playbackState, selection.url, load, toggle]);
-  
-  // Track info
-  const trackTitle = selection.track.title;
-  const trackArtist = selection.track.artist;
-  
-  const isLoading = playbackState === 'loading' || isPublishing;
-  const hasError = playbackState === 'error';
-  
-  return (
-    <div className="mx-4 sm:mx-6 mb-4">
-      <div className={cn(
-        "rounded-xl border bg-card/80 backdrop-blur-sm overflow-hidden",
-        "shadow-sm transition-all",
-        isPlaying && "ring-2 ring-pink-500/30"
-      )}>
-        {/* Main content row */}
-        <div className="flex items-center gap-3 p-3">
-          {/* Music icon / Now Playing indicator */}
-          <div className={cn(
-            "size-10 rounded-lg flex items-center justify-center shrink-0",
-            isPlaying 
-              ? "bg-pink-500/20" 
-              : "bg-muted"
-          )}>
-            <Music className={cn(
-              "size-5",
-              isPlaying ? "text-pink-500 animate-pulse" : "text-muted-foreground"
-            )} />
-          </div>
-          
-          {/* Track info */}
-          <div className="flex-1 min-w-0">
-            <p className="font-medium text-sm truncate">{trackTitle}</p>
-            {trackArtist && (
-              <p className="text-xs text-muted-foreground truncate">{trackArtist}</p>
-            )}
-            {!trackArtist && (
-              <p className="text-xs text-muted-foreground">
-                {isPlaying ? 'Now playing...' : isPublishing ? 'Starting...' : 'Ready to play'}
-              </p>
-            )}
-          </div>
-          
-          {/* Controls */}
-          <div className="flex items-center gap-1 shrink-0">
-            {/* Play/Pause button */}
-            <Button
-              size="icon"
-              variant="ghost"
-              onClick={handleToggle}
-              disabled={isLoading || !isPublished}
-              className="size-9 rounded-full"
-            >
-              {isLoading ? (
-                <Loader2 className="size-4 animate-spin" />
-              ) : isPlaying ? (
-                <Pause className="size-4" />
-              ) : (
-                <Play className="size-4 ml-0.5" />
-              )}
-            </Button>
-            
-            {/* Restart button - only show when actively playing or paused */}
-            {isPublished && (playbackState === 'playing' || playbackState === 'paused') && (
-              <Button
-                size="icon"
-                variant="ghost"
-                onClick={() => {
-                  restart();
-                }}
-                className="size-9 rounded-full"
-                title="Restart from beginning"
-              >
-                <RotateCcw className="size-3.5" />
-              </Button>
-            )}
-            
-            {/* Volume control */}
-            <Popover>
-              <PopoverTrigger asChild>
-                <Button
-                  size="icon"
-                  variant="ghost"
-                  className="size-9 rounded-full"
-                  title={volume === 0 ? 'Unmute' : 'Volume'}
-                >
-                  {volume === 0 ? (
-                    <VolumeX className="size-4" />
-                  ) : (
-                    <Volume2 className="size-4" />
-                  )}
-                </Button>
-              </PopoverTrigger>
-              <PopoverContent 
-                side="top" 
-                align="center" 
-                className="w-32 p-3"
-              >
-                <Slider
-                  value={[volume * 100]}
-                  onValueChange={([val]) => setVolume(val / 100)}
-                  max={100}
-                  step={1}
-                  className="w-full"
-                />
-              </PopoverContent>
-            </Popover>
-            
-            {/* Change track button */}
-            <Button
-              size="icon"
-              variant="ghost"
-              onClick={onChangeTrack}
-              disabled={isPublishing}
-              className="size-9 rounded-full"
-            >
-              <MoreHorizontal className="size-4" />
-            </Button>
-            
-            {/* Close button */}
-            <Button
-              size="icon"
-              variant="ghost"
-              onClick={handleClose}
-              disabled={isPublishing}
-              className="size-9 rounded-full text-muted-foreground hover:text-foreground"
-            >
-              <X className="size-4" />
-            </Button>
-          </div>
-        </div>
-        
-        {/* Error message */}
-        {hasError && playbackError && (
-          <div className="px-3 pb-3">
-            <div className="flex items-start gap-2 p-2 rounded-lg bg-amber-500/10 text-amber-600 dark:text-amber-400">
-              <AlertCircle className="size-4 mt-0.5 shrink-0" />
-              <p className="text-xs">{playbackError.message}</p>
-            </div>
-          </div>
-        )}
-      </div>
-    </div>
-  );
-}

src/blobbi/actions/components/InlineSingCard.tsx

@@ -1,487 +0,0 @@
-// src/blobbi/actions/components/InlineSingCard.tsx
-
-import { useState, useRef, useCallback, useEffect } from 'react';
-import { 
-  Mic, 
-  Play, 
-  Pause, 
-  Square, 
-  FileText, 
-  Check, 
-  X, 
-  Loader2, 
-  AlertCircle,
-  RefreshCw,
-} from 'lucide-react';
-
-import { Button } from '@/components/ui/button';
-import { cn } from '@/lib/utils';
-
-import { useAudioPlayback } from '../hooks/useAudioPlayback';
-import { getRandomLyrics, type LyricsEntry } from '../lib/blobbi-random-lyrics';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-type RecordingState = 'idle' | 'requesting' | 'recording' | 'recorded' | 'error';
-
-interface InlineSingCardProps {
-  /** Called when user confirms the singing action (publish the action) */
-  onConfirm: () => Promise<void>;
-  /** Called when user closes the sing card */
-  onClose: () => void;
-  /** Called when recording starts (for Blobbi reaction) */
-  onRecordingStart?: () => void;
-  /** Called when recording stops (for Blobbi reaction) */
-  onRecordingStop?: () => void;
-  /** Whether publishing is in progress */
-  isPublishing: boolean;
-}
-
-// ─── MIME Type Selection ──────────────────────────────────────────────────────
-
-const AUDIO_MIME_CANDIDATES = [
-  'audio/webm;codecs=opus',
-  'audio/webm',
-  'audio/mp4',
-  'audio/ogg;codecs=opus',
-  'audio/ogg',
-] as const;
-
-function getSupportedAudioMimeType(): string | undefined {
-  if (typeof MediaRecorder === 'undefined') {
-    return undefined;
-  }
-  
-  for (const mimeType of AUDIO_MIME_CANDIDATES) {
-    if (MediaRecorder.isTypeSupported(mimeType)) {
-      return mimeType;
-    }
-  }
-  
-  return undefined;
-}
-
-// ─── Component ────────────────────────────────────────────────────────────────
-
-export function InlineSingCard({
-  onConfirm,
-  onClose,
-  onRecordingStart,
-  onRecordingStop,
-  isPublishing,
-}: InlineSingCardProps) {
-  // Recording state
-  const [recordingState, setRecordingState] = useState<RecordingState>('idle');
-  const [recordingError, setRecordingError] = useState<string | null>(null);
-  const [recordingDuration, setRecordingDuration] = useState(0);
-  const [audioUrl, setAudioUrl] = useState<string | null>(null);
-  
-  // Lyrics state
-  const [currentLyrics, setCurrentLyrics] = useState<LyricsEntry | null>(null);
-  const [showLyrics, setShowLyrics] = useState(false);
-  
-  // Refs
-  const mediaRecorderRef = useRef<MediaRecorder | null>(null);
-  const chunksRef = useRef<Blob[]>([]);
-  const streamRef = useRef<MediaStream | null>(null);
-  const timerRef = useRef<ReturnType<typeof setInterval> | null>(null);
-  const actualMimeTypeRef = useRef<string | undefined>(undefined);
-  
-  // Audio playback for preview
-  const {
-    state: playbackState,
-    error: playbackError,
-    load: loadAudio,
-    toggle: togglePlayback,
-    stop: stopPlayback,
-    isPlaying,
-    cleanup: cleanupPlayback,
-  } = useAudioPlayback();
-  
-  // Cleanup all resources
-  const cleanupAll = useCallback(() => {
-    // Stop timer
-    if (timerRef.current) {
-      clearInterval(timerRef.current);
-      timerRef.current = null;
-    }
-    
-    // Stop media recorder
-    if (mediaRecorderRef.current && mediaRecorderRef.current.state !== 'inactive') {
-      try {
-        mediaRecorderRef.current.stop();
-      } catch {
-        // Ignore errors during cleanup
-      }
-    }
-    mediaRecorderRef.current = null;
-    
-    // Stop stream tracks
-    if (streamRef.current) {
-      streamRef.current.getTracks().forEach(track => track.stop());
-      streamRef.current = null;
-    }
-    
-    // Cleanup playback
-    cleanupPlayback();
-    
-    // Revoke URL
-    if (audioUrl) {
-      URL.revokeObjectURL(audioUrl);
-    }
-  }, [audioUrl, cleanupPlayback]);
-  
-  // Cleanup on unmount
-  useEffect(() => {
-    return () => {
-      cleanupAll();
-    };
-  }, [cleanupAll]);
-  
-  // Reset recording
-  const resetRecording = useCallback(() => {
-    cleanupAll();
-    setRecordingState('idle');
-    setRecordingError(null);
-    setRecordingDuration(0);
-    setAudioUrl(null);
-    chunksRef.current = [];
-    actualMimeTypeRef.current = undefined;
-    // Keep lyrics
-  }, [cleanupAll]);
-  
-  // Check browser support
-  const checkRecordingSupport = (): boolean => {
-    if (typeof navigator === 'undefined') return false;
-    if (!navigator.mediaDevices) return false;
-    if (!navigator.mediaDevices.getUserMedia) return false;
-    if (typeof MediaRecorder === 'undefined') return false;
-    return true;
-  };
-  
-  // Start recording
-  const startRecording = useCallback(async () => {
-    if (!checkRecordingSupport()) {
-      setRecordingError('Audio recording is not supported in this browser.');
-      setRecordingState('error');
-      return;
-    }
-    
-    setRecordingState('requesting');
-    setRecordingError(null);
-    
-    try {
-      const stream = await navigator.mediaDevices.getUserMedia({
-        audio: {
-          echoCancellation: true,
-          noiseSuppression: true,
-          autoGainControl: true,
-        }
-      });
-      
-      streamRef.current = stream;
-      chunksRef.current = [];
-      
-      // Get supported MIME type
-      const supportedMimeType = getSupportedAudioMimeType();
-      
-      // Create MediaRecorder
-      let mediaRecorder: MediaRecorder;
-      if (supportedMimeType) {
-        mediaRecorder = new MediaRecorder(stream, { mimeType: supportedMimeType });
-      } else {
-        mediaRecorder = new MediaRecorder(stream);
-      }
-      
-      actualMimeTypeRef.current = mediaRecorder.mimeType || supportedMimeType;
-      mediaRecorderRef.current = mediaRecorder;
-      
-      mediaRecorder.ondataavailable = (event) => {
-        if (event.data.size > 0) {
-          chunksRef.current.push(event.data);
-        }
-      };
-      
-      mediaRecorder.onstop = () => {
-        const blobMimeType = actualMimeTypeRef.current || 'audio/webm';
-        const blob = new Blob(chunksRef.current, { type: blobMimeType });
-        const url = URL.createObjectURL(blob);
-        setAudioUrl(url);
-        setRecordingState('recorded');
-        
-        if (streamRef.current) {
-          streamRef.current.getTracks().forEach(track => track.stop());
-          streamRef.current = null;
-        }
-      };
-      
-      mediaRecorder.onerror = () => {
-        setRecordingError('Recording failed. Please try again.');
-        setRecordingState('error');
-      };
-      
-      mediaRecorder.start(100);
-      setRecordingState('recording');
-      setRecordingDuration(0);
-      
-      // Notify parent that recording started (for Blobbi reaction)
-      onRecordingStart?.();
-      
-      timerRef.current = setInterval(() => {
-        setRecordingDuration(prev => prev + 1);
-      }, 1000);
-      
-    } catch (err) {
-      if (err instanceof Error) {
-        if (err.name === 'NotAllowedError' || err.name === 'PermissionDeniedError') {
-          setRecordingError('Microphone access was denied.');
-        } else if (err.name === 'NotFoundError') {
-          setRecordingError('No microphone found.');
-        } else {
-          setRecordingError(err.message);
-        }
-      } else {
-        setRecordingError('Failed to access microphone.');
-      }
-      setRecordingState('error');
-    }
-  }, [onRecordingStart]);
-  
-  // Stop recording
-  const stopRecording = useCallback(() => {
-    if (timerRef.current) {
-      clearInterval(timerRef.current);
-      timerRef.current = null;
-    }
-    
-    if (mediaRecorderRef.current && mediaRecorderRef.current.state !== 'inactive') {
-      mediaRecorderRef.current.stop();
-    }
-    
-    // Notify parent that recording stopped (for Blobbi reaction)
-    onRecordingStop?.();
-  }, [onRecordingStop]);
-  
-  // Handle preview playback
-  const handlePreview = useCallback(() => {
-    if (!audioUrl) return;
-    
-    if (playbackState === 'idle') {
-      loadAudio(audioUrl, true);
-    } else {
-      togglePlayback();
-    }
-  }, [audioUrl, playbackState, loadAudio, togglePlayback]);
-  
-  // Handle confirm
-  const handleConfirm = useCallback(async () => {
-    stopPlayback();
-    await onConfirm();
-    // After successful publish, close the card
-    onClose();
-  }, [stopPlayback, onConfirm, onClose]);
-  
-  // Handle close
-  const handleClose = useCallback(() => {
-    cleanupAll();
-    onClose();
-  }, [cleanupAll, onClose]);
-  
-  // Handle lyrics toggle
-  const handleLyricsToggle = useCallback(() => {
-    if (!currentLyrics && !showLyrics) {
-      // Generate lyrics on first open
-      setCurrentLyrics(getRandomLyrics());
-    }
-    setShowLyrics(!showLyrics);
-  }, [currentLyrics, showLyrics]);
-  
-  // Get new lyrics
-  const handleNewLyrics = useCallback(() => {
-    setCurrentLyrics(getRandomLyrics());
-  }, []);
-  
-  // Format duration
-  const formatDuration = (seconds: number) => {
-    const mins = Math.floor(seconds / 60);
-    const secs = seconds % 60;
-    return `${mins}:${secs.toString().padStart(2, '0')}`;
-  };
-  
-  const hasRecording = recordingState === 'recorded';
-  const isRecording = recordingState === 'recording';
-  const canConfirm = hasRecording && !isPublishing;
-  
-  return (
-    <div className="mx-4 sm:mx-6 mb-4">
-      <div className={cn(
-        "rounded-xl border bg-card/80 backdrop-blur-sm overflow-hidden",
-        "shadow-sm transition-all",
-        isRecording && "ring-2 ring-red-500/30"
-      )}>
-        {/* Lyrics panel (expands upward visually by being above controls) */}
-        {showLyrics && currentLyrics && (
-          <div className="px-3 pt-3 pb-2 border-b border-border/50">
-            <div className="flex items-center justify-between mb-2">
-              <span className="text-sm font-medium">{currentLyrics.title}</span>
-              <Button
-                size="icon"
-                variant="ghost"
-                onClick={handleNewLyrics}
-                className="size-7 rounded-full"
-              >
-                <RefreshCw className="size-3" />
-              </Button>
-            </div>
-            <div className="p-3 rounded-lg bg-muted/50 text-sm leading-relaxed whitespace-pre-line max-h-32 overflow-y-auto">
-              {currentLyrics.lines.join('\n')}
-            </div>
-          </div>
-        )}
-        
-        {/* Status row (recording/recorded info) */}
-        {(isRecording || hasRecording) && (
-          <div className="px-3 pt-3 pb-2 border-b border-border/50">
-            <div className="flex items-center justify-center gap-2">
-              {isRecording && (
-                <>
-                  <div className="size-2 rounded-full bg-red-500 animate-pulse" />
-                  <span className="text-sm font-mono font-medium text-red-500">
-                    {formatDuration(recordingDuration)}
-                  </span>
-                  <span className="text-xs text-muted-foreground">Recording...</span>
-                </>
-              )}
-              {hasRecording && !isRecording && (
-                <>
-                  <Check className="size-4 text-purple-500" />
-                  <span className="text-sm font-mono font-medium text-purple-500">
-                    {formatDuration(recordingDuration)}
-                  </span>
-                  <span className="text-xs text-muted-foreground">Recorded</span>
-                </>
-              )}
-            </div>
-          </div>
-        )}
-        
-        {/* Error message */}
-        {(recordingError || playbackError) && (
-          <div className="px-3 pt-2">
-            <div className="flex items-start gap-2 p-2 rounded-lg bg-amber-500/10 text-amber-600 dark:text-amber-400">
-              <AlertCircle className="size-4 mt-0.5 shrink-0" />
-              <p className="text-xs">{recordingError || playbackError?.message}</p>
-            </div>
-          </div>
-        )}
-        
-        {/* Main controls row */}
-        <div className="flex items-center justify-between gap-2 p-3">
-          {/* Left: Lyrics button */}
-          <Button
-            size="icon"
-            variant={showLyrics ? "secondary" : "ghost"}
-            onClick={handleLyricsToggle}
-            className="size-10 rounded-full shrink-0"
-          >
-            <FileText className="size-4" />
-          </Button>
-          
-          {/* Center: Record/Stop button */}
-          <div className="flex items-center gap-2">
-            {!isRecording && !hasRecording && (
-              <Button
-                onClick={startRecording}
-                disabled={isPublishing}
-                className="rounded-full px-6 bg-purple-500 hover:bg-purple-600"
-              >
-                <Mic className="size-4 mr-2" />
-                Sing
-              </Button>
-            )}
-            
-            {isRecording && (
-              <Button
-                onClick={stopRecording}
-                variant="destructive"
-                className="rounded-full px-6"
-              >
-                <Square className="size-4 mr-2" />
-                Stop
-              </Button>
-            )}
-            
-            {hasRecording && !isRecording && (
-              <>
-                <Button
-                  onClick={resetRecording}
-                  variant="outline"
-                  size="icon"
-                  className="size-10 rounded-full"
-                >
-                  <RefreshCw className="size-4" />
-                </Button>
-                
-                <Button
-                  onClick={handleConfirm}
-                  disabled={!canConfirm}
-                  className="rounded-full px-6 bg-purple-500 hover:bg-purple-600"
-                >
-                  {isPublishing ? (
-                    <Loader2 className="size-4 mr-2 animate-spin" />
-                  ) : (
-                    <Check className="size-4 mr-2" />
-                  )}
-                  {isPublishing ? 'Singing...' : 'Sing for Blobbi'}
-                </Button>
-              </>
-            )}
-          </div>
-          
-          {/* Right: Preview button (when recording exists) */}
-          {hasRecording ? (
-            <Button
-              size="icon"
-              variant="ghost"
-              onClick={handlePreview}
-              disabled={isPublishing}
-              className="size-10 rounded-full shrink-0"
-            >
-              {isPlaying ? (
-                <Pause className="size-4" />
-              ) : (
-                <Play className="size-4 ml-0.5" />
-              )}
-            </Button>
-          ) : (
-            /* Close button when no recording */
-            <Button
-              size="icon"
-              variant="ghost"
-              onClick={handleClose}
-              className="size-10 rounded-full shrink-0 text-muted-foreground hover:text-foreground"
-            >
-              <X className="size-4" />
-            </Button>
-          )}
-        </div>
-        
-        {/* Close button row when recording exists */}
-        {hasRecording && (
-          <div className="px-3 pb-3 pt-0 flex justify-end">
-            <Button
-              size="sm"
-              variant="ghost"
-              onClick={handleClose}
-              disabled={isPublishing}
-              className="text-muted-foreground hover:text-foreground"
-            >
-              <X className="size-3 mr-1" />
-              Cancel
-            </Button>
-          </div>
-        )}
-      </div>
-    </div>
-  );
-}

src/blobbi/actions/components/PlayMusicModal.tsx

@@ -1,301 +0,0 @@
-// src/blobbi/actions/components/PlayMusicModal.tsx
-
-import { useState, useRef, useCallback, useEffect } from 'react';
-import { Music, Play, Pause, Check, Loader2, Volume2, AlertCircle } from 'lucide-react';
-
-import {
-  Dialog,
-  DialogContent,
-  DialogHeader,
-  DialogTitle,
-} from '@/components/ui/dialog';
-import { Button } from '@/components/ui/button';
-import { cn } from '@/lib/utils';
-
-import {
-  getAllTracks,
-  formatTrackDuration,
-  type BlobbiTrack,
-} from '../lib/blobbi-track-catalog';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-/**
- * Selected track for the music player
- */
-export interface SelectedTrack {
-  track: BlobbiTrack;
-  url: string;
-}
-
-interface PlayMusicModalProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  /** Called with the selected track when user confirms */
-  onConfirm: (selection: SelectedTrack) => void;
-  isLoading: boolean;
-}
-
-// ─── Component ────────────────────────────────────────────────────────────────
-
-export function PlayMusicModal({
-  open,
-  onOpenChange,
-  onConfirm,
-  isLoading,
-}: PlayMusicModalProps) {
-  const [selectedTrack, setSelectedTrack] = useState<SelectedTrack | null>(null);
-  const [isPlaying, setIsPlaying] = useState(false);
-  const [error, setError] = useState<string | null>(null);
-  const audioRef = useRef<HTMLAudioElement | null>(null);
-  
-  // Track the current audio source URL to detect changes
-  const currentAudioUrlRef = useRef<string | null>(null);
-  
-  const tracks = getAllTracks();
-  
-  // Cleanup audio on unmount
-  useEffect(() => {
-    return () => {
-      if (audioRef.current) {
-        audioRef.current.pause();
-        audioRef.current = null;
-      }
-    };
-  }, []);
-  
-  // Reset state when modal opens
-  useEffect(() => {
-    if (open) {
-      setSelectedTrack(null);
-      setIsPlaying(false);
-      setError(null);
-      currentAudioUrlRef.current = null;
-    }
-  }, [open]);
-  
-  // Handle selecting a track
-  const handleSelectTrack = useCallback((track: BlobbiTrack) => {
-    // Stop current playback
-    if (audioRef.current) {
-      audioRef.current.pause();
-      setIsPlaying(false);
-    }
-    
-    setSelectedTrack({ track, url: track.url });
-    setError(null);
-  }, []);
-  
-  // Handle play/pause preview
-  const handleTogglePlay = useCallback(() => {
-    if (!selectedTrack) return;
-    
-    const audioUrl = selectedTrack.url;
-    
-    // Check if we need to create a new Audio instance (source changed or first time)
-    const needsNewAudio = !audioRef.current || currentAudioUrlRef.current !== audioUrl;
-    
-    if (needsNewAudio) {
-      // Stop and cleanup old audio if exists
-      if (audioRef.current) {
-        audioRef.current.pause();
-        audioRef.current.onended = null;
-        audioRef.current.onerror = null;
-      }
-      
-      // Create new Audio instance with the correct source
-      audioRef.current = new Audio(audioUrl);
-      currentAudioUrlRef.current = audioUrl;
-      
-      audioRef.current.onended = () => setIsPlaying(false);
-      audioRef.current.onerror = () => {
-        setError('Failed to load this track. Please try another one.');
-        setIsPlaying(false);
-      };
-    }
-    
-    if (isPlaying && !needsNewAudio) {
-      // Pause current playback
-      audioRef.current?.pause();
-      setIsPlaying(false);
-    } else {
-      // Start playback (either new source or resuming)
-      audioRef.current?.play().catch(() => {
-        setError('Failed to play this track. Please try another one.');
-        setIsPlaying(false);
-      });
-      setIsPlaying(true);
-    }
-  }, [selectedTrack, isPlaying]);
-  
-  // Handle confirm
-  const handleConfirm = useCallback(() => {
-    if (!selectedTrack) return;
-    
-    // Stop playback
-    if (audioRef.current) {
-      audioRef.current.pause();
-      setIsPlaying(false);
-    }
-    onConfirm(selectedTrack);
-  }, [selectedTrack, onConfirm]);
-  
-  // Handle close
-  const handleClose = useCallback((isOpen: boolean) => {
-    if (!isOpen && audioRef.current) {
-      audioRef.current.pause();
-      setIsPlaying(false);
-    }
-    onOpenChange(isOpen);
-  }, [onOpenChange]);
-
-  return (
-    <Dialog open={open} onOpenChange={handleClose}>
-      <DialogContent className="max-w-md max-h-[85vh] flex flex-col p-0">
-        {/* Header */}
-        <DialogHeader className="px-6 pt-6 pb-4 border-b">
-          <div className="flex items-center gap-3">
-            <div className="size-10 rounded-xl bg-gradient-to-br from-pink-500/20 to-pink-500/5 flex items-center justify-center">
-              <Music className="size-5 text-pink-500" />
-            </div>
-            <div>
-              <DialogTitle className="text-xl">Play Music</DialogTitle>
-              <p className="text-sm text-muted-foreground">
-                Choose a track to play for your Blobbi
-              </p>
-            </div>
-          </div>
-        </DialogHeader>
-
-        {/* Content - Track List */}
-        <div className="flex-1 overflow-y-auto px-6 py-4">
-          <div className="grid gap-2">
-            {tracks.map((track) => (
-              <TrackRow
-                key={track.id}
-                track={track}
-                isSelected={selectedTrack?.track.id === track.id}
-                onSelect={() => handleSelectTrack(track)}
-              />
-            ))}
-          </div>
-          {error && (
-            <div className="mt-4 p-3 rounded-lg bg-amber-500/10 border border-amber-500/30">
-              <div className="flex items-start gap-2">
-                <AlertCircle className="size-4 text-amber-500 mt-0.5 shrink-0" />
-                <p className="text-sm text-amber-600 dark:text-amber-400">{error}</p>
-              </div>
-            </div>
-          )}
-        </div>
-
-        {/* Footer */}
-        <div className="px-6 py-4 border-t bg-muted/30">
-          {/* Preview Controls */}
-          {selectedTrack && (
-            <div className="mb-4 p-3 rounded-lg bg-card border">
-              <div className="flex items-center gap-3">
-                <Button
-                  size="icon"
-                  variant="outline"
-                  onClick={handleTogglePlay}
-                  className="size-10 rounded-full shrink-0"
-                >
-                  {isPlaying ? (
-                    <Pause className="size-4" />
-                  ) : (
-                    <Play className="size-4 ml-0.5" />
-                  )}
-                </Button>
-                <div className="flex-1 min-w-0">
-                  <p className="font-medium truncate text-sm">{selectedTrack.track.title}</p>
-                  <p className="text-xs text-muted-foreground">
-                    {isPlaying ? 'Now playing...' : 'Click to preview'}
-                  </p>
-                </div>
-                {isPlaying && (
-                  <Volume2 className="size-4 text-primary animate-pulse shrink-0" />
-                )}
-              </div>
-            </div>
-          )}
-          
-          {/* Action Buttons */}
-          <div className="flex gap-3">
-            <Button
-              variant="outline"
-              onClick={() => handleClose(false)}
-              className="flex-1"
-              disabled={isLoading}
-            >
-              Cancel
-            </Button>
-            <Button
-              onClick={handleConfirm}
-              disabled={!selectedTrack || isLoading}
-              className="flex-1"
-            >
-              {isLoading ? (
-                <>
-                  <Loader2 className="size-4 mr-2 animate-spin" />
-                  Playing...
-                </>
-              ) : (
-                <>
-                  <Music className="size-4 mr-2" />
-                  Play for Blobbi
-                </>
-              )}
-            </Button>
-          </div>
-        </div>
-      </DialogContent>
-    </Dialog>
-  );
-}
-
-// ─── Track Row Component ──────────────────────────────────────────────────────
-
-interface TrackRowProps {
-  track: BlobbiTrack;
-  isSelected: boolean;
-  onSelect: () => void;
-}
-
-function TrackRow({ track, isSelected, onSelect }: TrackRowProps) {
-  return (
-    <button
-      type="button"
-      onClick={onSelect}
-      className={cn(
-        "w-full p-3 rounded-xl text-left transition-all",
-        "border hover:border-primary/30",
-        isSelected 
-          ? "border-primary bg-primary/5 ring-2 ring-primary/20" 
-          : "border-border bg-card/60"
-      )}
-    >
-      <div className="flex items-center gap-3">
-        <div className={cn(
-          "size-10 rounded-lg flex items-center justify-center",
-          isSelected ? "bg-primary/20" : "bg-muted"
-        )}>
-          <Music className={cn(
-            "size-5",
-            isSelected ? "text-primary" : "text-muted-foreground"
-          )} />
-        </div>
-        <div className="flex-1 min-w-0">
-          <p className="font-medium truncate">{track.title}</p>
-          <p className="text-sm text-muted-foreground">{track.artist}</p>
-        </div>
-        <div className="flex items-center gap-2 shrink-0">
-          <span className="text-sm text-muted-foreground">
-            {formatTrackDuration(track.durationSeconds)}
-          </span>
-          {isSelected && <Check className="size-4 text-primary" />}
-        </div>
-      </div>
-    </button>
-  );
-}

src/blobbi/actions/components/SingModal.tsx

@@ -1,601 +0,0 @@
-// src/blobbi/actions/components/SingModal.tsx
-
-import { useState, useRef, useCallback, useEffect } from 'react';
-import { Mic, MicOff, Play, Pause, Square, Loader2, AlertCircle, RotateCcw, Sparkles, ChevronDown, ChevronUp } from 'lucide-react';
-
-import {
-  Dialog,
-  DialogContent,
-  DialogHeader,
-  DialogTitle,
-} from '@/components/ui/dialog';
-import { Button } from '@/components/ui/button';
-import { cn } from '@/lib/utils';
-
-import { getRandomLyrics, type LyricsEntry } from '../lib/blobbi-random-lyrics';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-interface SingModalProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  onConfirm: () => void;
-  isLoading: boolean;
-}
-
-type RecordingState = 'idle' | 'requesting' | 'recording' | 'recorded' | 'playing' | 'error';
-
-// ─── MIME Type Selection Helper ───────────────────────────────────────────────
-
-/**
- * Ordered list of MIME types to try for audio recording.
- * The first supported type will be used.
- */
-const AUDIO_MIME_CANDIDATES = [
-  'audio/webm;codecs=opus',
-  'audio/webm',
-  'audio/mp4',
-  'audio/ogg;codecs=opus',
-  'audio/ogg',
-] as const;
-
-/**
- * Get the first supported MIME type for MediaRecorder.
- * Returns undefined if no explicit MIME type is supported (let browser decide).
- */
-function getSupportedAudioMimeType(): string | undefined {
-  if (typeof MediaRecorder === 'undefined') {
-    return undefined;
-  }
-  
-  for (const mimeType of AUDIO_MIME_CANDIDATES) {
-    if (MediaRecorder.isTypeSupported(mimeType)) {
-      return mimeType;
-    }
-  }
-  
-  // No explicit MIME type supported, let browser use default
-  return undefined;
-}
-
-// ─── Component ────────────────────────────────────────────────────────────────
-
-export function SingModal({
-  open,
-  onOpenChange,
-  onConfirm,
-  isLoading,
-}: SingModalProps) {
-  const [recordingState, setRecordingState] = useState<RecordingState>('idle');
-  const [error, setError] = useState<string | null>(null);
-  const [playbackError, setPlaybackError] = useState<string | null>(null);
-  const [recordingDuration, setRecordingDuration] = useState(0);
-  const [audioUrl, setAudioUrl] = useState<string | null>(null);
-  const [currentLyrics, setCurrentLyrics] = useState<LyricsEntry | null>(null);
-  const [showLyrics, setShowLyrics] = useState(false);
-  
-  const mediaRecorderRef = useRef<MediaRecorder | null>(null);
-  const chunksRef = useRef<Blob[]>([]);
-  const streamRef = useRef<MediaStream | null>(null);
-  const audioRef = useRef<HTMLAudioElement | null>(null);
-  const timerRef = useRef<ReturnType<typeof setInterval> | null>(null);
-  // Track the actual MIME type used by the recorder
-  const actualMimeTypeRef = useRef<string | undefined>(undefined);
-  
-  const cleanup = useCallback(() => {
-    // Stop timer
-    if (timerRef.current) {
-      clearInterval(timerRef.current);
-      timerRef.current = null;
-    }
-    
-    // Stop media recorder
-    if (mediaRecorderRef.current && mediaRecorderRef.current.state !== 'inactive') {
-      mediaRecorderRef.current.stop();
-    }
-    mediaRecorderRef.current = null;
-    
-    // Stop stream tracks
-    if (streamRef.current) {
-      streamRef.current.getTracks().forEach(track => track.stop());
-      streamRef.current = null;
-    }
-    
-    // Stop audio playback
-    if (audioRef.current) {
-      audioRef.current.pause();
-      audioRef.current = null;
-    }
-    
-    // Revoke URL
-    if (audioUrl) {
-      URL.revokeObjectURL(audioUrl);
-    }
-  }, [audioUrl]);
-  
-  const resetRecording = useCallback(() => {
-    cleanup();
-    setRecordingState('idle');
-    setError(null);
-    setPlaybackError(null);
-    setRecordingDuration(0);
-    setAudioUrl(null);
-    chunksRef.current = [];
-    currentPlaybackUrlRef.current = null;
-    actualMimeTypeRef.current = undefined;
-    // Keep lyrics when re-recording so user can sing the same song
-  }, [cleanup]);
-  
-  // Cleanup on unmount
-  useEffect(() => {
-    return () => {
-      cleanup();
-    };
-  }, [cleanup]);
-  
-  // Reset state when modal opens
-  useEffect(() => {
-    if (open) {
-      resetRecording();
-    } else {
-      cleanup();
-    }
-  }, [open, cleanup, resetRecording]);
-  
-  // Handle getting random lyrics
-  const handleRandomLyrics = useCallback(() => {
-    const lyrics = getRandomLyrics();
-    setCurrentLyrics(lyrics);
-    setShowLyrics(true);
-  }, []);
-  
-  // Check if browser supports media recording
-  const checkRecordingSupport = (): boolean => {
-    if (typeof navigator === 'undefined') return false;
-    if (!navigator.mediaDevices) return false;
-    if (!navigator.mediaDevices.getUserMedia) return false;
-    if (typeof MediaRecorder === 'undefined') return false;
-    return true;
-  };
-  
-  // Start recording
-  const startRecording = useCallback(async () => {
-    if (!checkRecordingSupport()) {
-      setError('Audio recording is not supported in this browser.');
-      setRecordingState('error');
-      return;
-    }
-    
-    setRecordingState('requesting');
-    setError(null);
-    setPlaybackError(null);
-    
-    try {
-      const stream = await navigator.mediaDevices.getUserMedia({ 
-        audio: {
-          echoCancellation: true,
-          noiseSuppression: true,
-          autoGainControl: true,
-        }
-      });
-      
-      streamRef.current = stream;
-      chunksRef.current = [];
-      
-      // Get the first supported MIME type using our helper
-      const supportedMimeType = getSupportedAudioMimeType();
-      
-      // Create MediaRecorder with or without explicit MIME type
-      let mediaRecorder: MediaRecorder;
-      if (supportedMimeType) {
-        mediaRecorder = new MediaRecorder(stream, { mimeType: supportedMimeType });
-      } else {
-        // Let browser choose default MIME type
-        mediaRecorder = new MediaRecorder(stream);
-      }
-      
-      // Store the actual MIME type being used (may differ from what we requested)
-      actualMimeTypeRef.current = mediaRecorder.mimeType || supportedMimeType;
-      mediaRecorderRef.current = mediaRecorder;
-      
-      mediaRecorder.ondataavailable = (event) => {
-        if (event.data.size > 0) {
-          chunksRef.current.push(event.data);
-        }
-      };
-      
-      mediaRecorder.onstop = () => {
-        // Create blob from chunks using the actual MIME type used by the recorder
-        const blobMimeType = actualMimeTypeRef.current || 'audio/webm';
-        const blob = new Blob(chunksRef.current, { type: blobMimeType });
-        const url = URL.createObjectURL(blob);
-        setAudioUrl(url);
-        setRecordingState('recorded');
-        
-        // Stop stream tracks
-        if (streamRef.current) {
-          streamRef.current.getTracks().forEach(track => track.stop());
-          streamRef.current = null;
-        }
-      };
-      
-      mediaRecorder.onerror = () => {
-        setError('Recording failed. Please try again.');
-        setRecordingState('error');
-      };
-      
-      // Start recording
-      mediaRecorder.start(100); // Collect data every 100ms
-      setRecordingState('recording');
-      setRecordingDuration(0);
-      
-      // Start timer
-      timerRef.current = setInterval(() => {
-        setRecordingDuration(prev => prev + 1);
-      }, 1000);
-      
-    } catch (err) {
-      if (err instanceof Error) {
-        if (err.name === 'NotAllowedError' || err.name === 'PermissionDeniedError') {
-          setError('Microphone access was denied. Please allow microphone access and try again.');
-        } else if (err.name === 'NotFoundError') {
-          setError('No microphone found. Please connect a microphone and try again.');
-        } else {
-          setError(`Failed to access microphone: ${err.message}`);
-        }
-      } else {
-        setError('Failed to access microphone. Please try again.');
-      }
-      setRecordingState('error');
-    }
-  }, []);
-  
-  // Stop recording
-  const stopRecording = useCallback(() => {
-    if (timerRef.current) {
-      clearInterval(timerRef.current);
-      timerRef.current = null;
-    }
-    
-    if (mediaRecorderRef.current && mediaRecorderRef.current.state !== 'inactive') {
-      mediaRecorderRef.current.stop();
-    }
-  }, []);
-  
-  // Track the current audio URL to detect changes
-  const currentPlaybackUrlRef = useRef<string | null>(null);
-  
-  // Play/pause preview
-  const togglePlayback = useCallback(() => {
-    if (!audioUrl) return;
-    
-    // Clear previous playback error when attempting to play
-    setPlaybackError(null);
-    
-    if (recordingState === 'playing') {
-      if (audioRef.current) {
-        audioRef.current.pause();
-      }
-      setRecordingState('recorded');
-    } else {
-      // Check if we need to create a new Audio instance (URL changed or first time)
-      const needsNewAudio = !audioRef.current || currentPlaybackUrlRef.current !== audioUrl;
-      
-      if (needsNewAudio) {
-        // Cleanup old audio if exists
-        if (audioRef.current) {
-          audioRef.current.pause();
-          audioRef.current.onended = null;
-          audioRef.current.onerror = null;
-        }
-        
-        // Create new Audio instance with the recorded audio URL
-        audioRef.current = new Audio(audioUrl);
-        currentPlaybackUrlRef.current = audioUrl;
-        audioRef.current.onended = () => setRecordingState('recorded');
-        
-        // Handle playback errors with user-visible message
-        audioRef.current.onerror = () => {
-          setPlaybackError('This browser could not play the recorded audio preview. Your recording was still created successfully.');
-          setRecordingState('recorded');
-        };
-      }
-      
-      audioRef.current?.play()
-        .then(() => {
-          setRecordingState('playing');
-        })
-        .catch((err) => {
-          console.error('Failed to play recording:', err);
-          // Provide user-friendly error message
-          if (err.name === 'NotSupportedError') {
-            setPlaybackError('Recording was created, but playback preview is not supported in this browser.');
-          } else if (err.name === 'NotAllowedError') {
-            setPlaybackError('Playback was blocked. Try interacting with the page first.');
-          } else {
-            setPlaybackError('Could not play the recording preview. Your recording was still created successfully.');
-          }
-          setRecordingState('recorded');
-        });
-    }
-  }, [audioUrl, recordingState]);
-  
-  // Handle confirm
-  const handleConfirm = useCallback(() => {
-    if (audioRef.current) {
-      audioRef.current.pause();
-    }
-    onConfirm();
-  }, [onConfirm]);
-  
-  // Handle close
-  const handleClose = useCallback((isOpen: boolean) => {
-    if (!isOpen) {
-      cleanup();
-    }
-    onOpenChange(isOpen);
-  }, [onOpenChange, cleanup]);
-  
-  // Format duration
-  const formatDuration = (seconds: number) => {
-    const mins = Math.floor(seconds / 60);
-    const secs = seconds % 60;
-    return `${mins}:${secs.toString().padStart(2, '0')}`;
-  };
-  
-  const hasRecording = recordingState === 'recorded' || recordingState === 'playing';
-
-  return (
-    <Dialog open={open} onOpenChange={handleClose}>
-      <DialogContent className="max-w-md max-h-[85vh] flex flex-col p-0">
-        {/* Header */}
-        <DialogHeader className="px-6 pt-6 pb-4 border-b">
-          <div className="flex items-center gap-3">
-            <div className="size-10 rounded-xl bg-gradient-to-br from-purple-500/20 to-purple-500/5 flex items-center justify-center">
-              <Mic className="size-5 text-purple-500" />
-            </div>
-            <div>
-              <DialogTitle className="text-xl">Sing</DialogTitle>
-              <p className="text-sm text-muted-foreground">
-                Record yourself singing for your Blobbi
-              </p>
-            </div>
-          </div>
-        </DialogHeader>
-
-        {/* Content */}
-        <div className="flex-1 px-6 py-8">
-          <div className="flex flex-col items-center justify-center gap-6">
-            {/* Recording Visualization */}
-            <div className={cn(
-              "relative size-40 rounded-full flex items-center justify-center transition-all",
-              recordingState === 'recording' && "animate-pulse",
-              recordingState === 'recording' 
-                ? "bg-red-500/10 ring-4 ring-red-500/30" 
-                : hasRecording
-                ? "bg-purple-500/10 ring-4 ring-purple-500/30"
-                : "bg-muted"
-            )}>
-              {/* Animated rings for recording */}
-              {recordingState === 'recording' && (
-                <>
-                  <div className="absolute inset-0 rounded-full bg-red-500/10 animate-ping" />
-                  <div className="absolute inset-4 rounded-full bg-red-500/10 animate-ping animation-delay-150" />
-                </>
-              )}
-              
-              {/* Icon */}
-              <div className={cn(
-                "relative size-20 rounded-full flex items-center justify-center",
-                recordingState === 'recording' 
-                  ? "bg-red-500 text-white" 
-                  : hasRecording
-                  ? "bg-purple-500 text-white"
-                  : "bg-muted-foreground/20"
-              )}>
-                {recordingState === 'requesting' ? (
-                  <Loader2 className="size-8 animate-spin" />
-                ) : recordingState === 'recording' ? (
-                  <Mic className="size-8" />
-                ) : hasRecording ? (
-                  recordingState === 'playing' ? (
-                    <Pause className="size-8" />
-                  ) : (
-                    <Play className="size-8 ml-1" />
-                  )
-                ) : (
-                  <MicOff className="size-8 text-muted-foreground" />
-                )}
-              </div>
-            </div>
-            
-            {/* Duration / Status */}
-            <div className="text-center">
-              {recordingState === 'idle' && (
-                <p className="text-muted-foreground">Tap the button below to start recording</p>
-              )}
-              {recordingState === 'requesting' && (
-                <p className="text-muted-foreground">Requesting microphone access...</p>
-              )}
-              {recordingState === 'recording' && (
-                <>
-                  <p className="text-3xl font-mono font-bold text-red-500">
-                    {formatDuration(recordingDuration)}
-                  </p>
-                  <p className="text-sm text-muted-foreground mt-1">Recording...</p>
-                </>
-              )}
-              {hasRecording && (
-                <>
-                  <p className="text-3xl font-mono font-bold text-purple-500">
-                    {formatDuration(recordingDuration)}
-                  </p>
-                  <p className="text-sm text-muted-foreground mt-1">
-                    {recordingState === 'playing' ? 'Playing...' : 'Tap to preview'}
-                  </p>
-                </>
-              )}
-              {recordingState === 'error' && (
-                <p className="text-destructive">Recording failed</p>
-              )}
-            </div>
-            
-            {/* Error Message */}
-            {error && (
-              <div className="w-full p-3 rounded-lg bg-destructive/10 border border-destructive/30">
-                <div className="flex items-start gap-2">
-                  <AlertCircle className="size-4 text-destructive mt-0.5 shrink-0" />
-                  <p className="text-sm text-destructive">{error}</p>
-                </div>
-              </div>
-            )}
-            
-            {/* Playback Error Message (non-fatal, recording still works) */}
-            {playbackError && (
-              <div className="w-full p-3 rounded-lg bg-amber-500/10 border border-amber-500/30">
-                <div className="flex items-start gap-2">
-                  <AlertCircle className="size-4 text-amber-500 mt-0.5 shrink-0" />
-                  <p className="text-sm text-amber-600 dark:text-amber-400">{playbackError}</p>
-                </div>
-              </div>
-            )}
-            
-            {/* Lyrics Helper */}
-            <div className="w-full">
-              {!currentLyrics ? (
-                <Button
-                  variant="outline"
-                  size="sm"
-                  onClick={handleRandomLyrics}
-                  className="w-full gap-2"
-                >
-                  <Sparkles className="size-4" />
-                  Need lyrics? Get random lyrics
-                </Button>
-              ) : (
-                <div className="rounded-lg border bg-card/60">
-                  <button
-                    type="button"
-                    onClick={() => setShowLyrics(!showLyrics)}
-                    className="w-full flex items-center justify-between p-3 text-left"
-                  >
-                    <div className="flex items-center gap-2">
-                      <Sparkles className="size-4 text-purple-500" />
-                      <span className="font-medium text-sm">{currentLyrics.title}</span>
-                    </div>
-                    {showLyrics ? (
-                      <ChevronUp className="size-4 text-muted-foreground" />
-                    ) : (
-                      <ChevronDown className="size-4 text-muted-foreground" />
-                    )}
-                  </button>
-                  {showLyrics && (
-                    <div className="px-3 pb-3 pt-0">
-                      <div className="p-3 rounded-md bg-muted/50 text-sm leading-relaxed whitespace-pre-line">
-                        {currentLyrics.lines.join('\n')}
-                      </div>
-                      <Button
-                        variant="ghost"
-                        size="sm"
-                        onClick={handleRandomLyrics}
-                        className="w-full mt-2 gap-2 text-muted-foreground"
-                      >
-                        <RotateCcw className="size-3" />
-                        Get different lyrics
-                      </Button>
-                    </div>
-                  )}
-                </div>
-              )}
-            </div>
-            
-            {/* Recording Controls */}
-            <div className="flex items-center gap-3">
-              {recordingState === 'idle' || recordingState === 'error' ? (
-                <Button
-                  size="lg"
-                  onClick={startRecording}
-                  className="rounded-full px-8 bg-purple-500 hover:bg-purple-600"
-                >
-                  <Mic className="size-5 mr-2" />
-                  Start Recording
-                </Button>
-              ) : recordingState === 'recording' ? (
-                <Button
-                  size="lg"
-                  variant="destructive"
-                  onClick={stopRecording}
-                  className="rounded-full px-8"
-                >
-                  <Square className="size-5 mr-2" />
-                  Stop
-                </Button>
-              ) : hasRecording ? (
-                <>
-                  <Button
-                    size="lg"
-                    variant="outline"
-                    onClick={togglePlayback}
-                    className="rounded-full"
-                  >
-                    {recordingState === 'playing' ? (
-                      <>
-                        <Pause className="size-5 mr-2" />
-                        Pause
-                      </>
-                    ) : (
-                      <>
-                        <Play className="size-5 mr-2" />
-                        Preview
-                      </>
-                    )}
-                  </Button>
-                  <Button
-                    size="lg"
-                    variant="ghost"
-                    onClick={resetRecording}
-                    className="rounded-full"
-                  >
-                    <RotateCcw className="size-5 mr-2" />
-                    Re-record
-                  </Button>
-                </>
-              ) : null}
-            </div>
-          </div>
-        </div>
-
-        {/* Footer */}
-        <div className="px-6 py-4 border-t bg-muted/30">
-          <div className="flex gap-3">
-            <Button
-              variant="outline"
-              onClick={() => handleClose(false)}
-              className="flex-1"
-              disabled={isLoading}
-            >
-              Cancel
-            </Button>
-            <Button
-              onClick={handleConfirm}
-              disabled={!hasRecording || isLoading}
-              className="flex-1"
-            >
-              {isLoading ? (
-                <>
-                  <Loader2 className="size-4 mr-2 animate-spin" />
-                  Singing...
-                </>
-              ) : (
-                <>
-                  <Mic className="size-4 mr-2" />
-                  Sing for Blobbi
-                </>
-              )}
-            </Button>
-          </div>
-        </div>
-      </DialogContent>
-    </Dialog>
-  );
-}

src/blobbi/actions/components/StartEvolutionDialog.tsx

@@ -1,125 +0,0 @@
-// src/blobbi/actions/components/StartEvolutionDialog.tsx
-
-/**
- * Dialog for confirming start of evolution.
- * 
- * Evolution is simpler than incubation:
- * - Only baby Blobbis can evolve
- * - Shows restart confirmation if already evolving
- * - Otherwise shows normal start confirmation
- */
-
-import { Loader2, AlertTriangle, Sparkles } from 'lucide-react';
-
-import {
-  AlertDialog,
-  AlertDialogAction,
-  AlertDialogCancel,
-  AlertDialogContent,
-  AlertDialogDescription,
-  AlertDialogFooter,
-  AlertDialogHeader,
-  AlertDialogTitle,
-} from '@/components/ui/alert-dialog';
-
-import type { BlobbiCompanion } from '@/blobbi/core/lib/blobbi';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-interface StartEvolutionDialogProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  /** The companion to start evolving */
-  companion: BlobbiCompanion | null;
-  /** Called when confirmed */
-  onConfirm: () => void;
-  isPending: boolean;
-}
-
-// ─── Main Component ───────────────────────────────────────────────────────────
-
-export function StartEvolutionDialog({
-  open,
-  onOpenChange,
-  companion,
-  onConfirm,
-  isPending,
-}: StartEvolutionDialogProps) {
-  // Check if the current Blobbi is already evolving
-  const isAlreadyEvolving = companion?.state === 'evolving';
-  
-  // Determine title and description based on state
-  const getDialogContent = () => {
-    if (isAlreadyEvolving) {
-      return {
-        title: 'Restart Evolution?',
-        icon: <AlertTriangle className="size-5 text-amber-500" />,
-        description: (
-          <>
-            <strong>{companion?.name}</strong> is already evolving. Starting over will{' '}
-            <strong>reset all task progress</strong> and begin from the beginning.
-            <br /><br />
-            Are you sure you want to restart?
-          </>
-        ),
-        buttonText: 'Restart Evolution',
-        buttonClass: 'bg-amber-500 hover:bg-amber-600 text-white',
-      };
-    }
-    
-    return {
-      title: 'Start Evolution',
-      icon: <Sparkles className="size-5 text-primary" />,
-      description: (
-        <>
-          Starting evolution begins <strong>{companion?.name}</strong>'s transformation journey.
-          Complete all the tasks to evolve your baby Blobbi into an adult!
-          <br /><br />
-          Ready to begin?
-        </>
-      ),
-      buttonText: 'Start Evolution',
-      buttonClass: 'bg-gradient-to-r from-violet-500 to-purple-500 hover:from-violet-600 hover:to-purple-600 text-white',
-    };
-  };
-  
-  const content = getDialogContent();
-  
-  return (
-    <AlertDialog open={open} onOpenChange={onOpenChange}>
-      <AlertDialogContent>
-        <AlertDialogHeader>
-          <AlertDialogTitle className="flex items-center gap-2">
-            {content.icon}
-            {content.title}
-          </AlertDialogTitle>
-          <AlertDialogDescription>
-            {content.description}
-          </AlertDialogDescription>
-        </AlertDialogHeader>
-        <AlertDialogFooter>
-          <AlertDialogCancel disabled={isPending}>
-            Cancel
-          </AlertDialogCancel>
-          <AlertDialogAction
-            onClick={(e) => {
-              e.preventDefault();
-              onConfirm();
-            }}
-            disabled={isPending}
-            className={content.buttonClass}
-          >
-            {isPending ? (
-              <>
-                <Loader2 className="size-4 mr-2 animate-spin" />
-                Starting...
-              </>
-            ) : (
-              content.buttonText
-            )}
-          </AlertDialogAction>
-        </AlertDialogFooter>
-      </AlertDialogContent>
-    </AlertDialog>
-  );
-}

src/blobbi/actions/components/StartIncubationDialog.tsx

@@ -1,180 +0,0 @@
-// src/blobbi/actions/components/StartIncubationDialog.tsx
-
-/**
- * Dialog for confirming start of incubation.
- * 
- * Determines the mode and passes it explicitly to the confirm callback:
- * - 'start': Normal start, no other Blobbi incubating
- * - 'restart': Restart same Blobbi (already incubating)
- * - 'switch': Stop another Blobbi first, then start this one
- * 
- * The mode is determined by UI state, NOT auto-detected by the hook.
- * This makes the flow explicit and predictable.
- */
-
-import { useMemo } from 'react';
-import { Loader2, AlertTriangle, ArrowRightLeft } from 'lucide-react';
-
-import {
-  AlertDialog,
-  AlertDialogAction,
-  AlertDialogCancel,
-  AlertDialogContent,
-  AlertDialogDescription,
-  AlertDialogFooter,
-  AlertDialogHeader,
-  AlertDialogTitle,
-} from '@/components/ui/alert-dialog';
-
-import type { BlobbiCompanion } from '@/blobbi/core/lib/blobbi';
-import type { StartIncubationMode } from '../hooks/useBlobbiIncubation';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-interface StartIncubationDialogProps {
-  open: boolean;
-  onOpenChange: (open: boolean) => void;
-  /** The companion to start incubating */
-  companion: BlobbiCompanion | null;
-  /** All companions in the collection (to check for other incubating Blobbis) */
-  companions?: BlobbiCompanion[];
-  /** Called with explicit mode and optional stopOtherD when confirmed */
-  onConfirm: (mode: StartIncubationMode, stopOtherD?: string) => void;
-  isPending: boolean;
-}
-
-// ─── Main Component ───────────────────────────────────────────────────────────
-
-export function StartIncubationDialog({
-  open,
-  onOpenChange,
-  companion,
-  companions = [],
-  onConfirm,
-  isPending,
-}: StartIncubationDialogProps) {
-  // Check if the current Blobbi is already in a task state
-  const isAlreadyInTaskState = companion?.state === 'incubating' || companion?.state === 'evolving';
-  
-  // Check if another Blobbi (not this one) is currently incubating
-  const otherIncubatingBlobbi = useMemo(() => {
-    if (!companion) return null;
-    return companions.find(c => 
-      c.d !== companion.d && 
-      c.state === 'incubating' &&
-      c.stage === 'egg'
-    ) ?? null;
-  }, [companion, companions]);
-  
-  // Determine the mode based on current state
-  const mode: StartIncubationMode = useMemo(() => {
-    if (isAlreadyInTaskState) return 'restart';
-    if (otherIncubatingBlobbi) return 'switch';
-    return 'start';
-  }, [isAlreadyInTaskState, otherIncubatingBlobbi]);
-  
-  // Handle confirm with explicit mode
-  const handleConfirm = () => {
-    if (mode === 'switch' && otherIncubatingBlobbi) {
-      onConfirm(mode, otherIncubatingBlobbi.d);
-    } else {
-      onConfirm(mode);
-    }
-  };
-  
-  // Determine title and description based on mode
-  const getDialogContent = () => {
-    if (mode === 'restart') {
-      return {
-        title: 'Restart Incubation?',
-        icon: <AlertTriangle className="size-5 text-amber-500" />,
-        description: (
-          <>
-            Your Blobbi is already {companion?.state}. Starting over will{' '}
-            <strong>reset all task progress</strong> and begin from the beginning.
-            <br /><br />
-            Are you sure you want to restart?
-          </>
-        ),
-        buttonText: 'Restart Incubation',
-        buttonClass: 'bg-amber-500 hover:bg-amber-600 text-white',
-      };
-    }
-    
-    if (mode === 'switch') {
-      return {
-        title: 'Switch Incubation?',
-        icon: <ArrowRightLeft className="size-5 text-amber-500" />,
-        description: (
-          <>
-            <strong>{otherIncubatingBlobbi?.name}</strong> is currently incubating.
-            Only one Blobbi can incubate at a time.
-            <br /><br />
-            Starting incubation for <strong>{companion?.name}</strong> will{' '}
-            <strong>stop {otherIncubatingBlobbi?.name}'s incubation</strong> and{' '}
-            reset their task progress.
-            <br /><br />
-            Do you want to switch?
-          </>
-        ),
-        buttonText: 'Switch & Start',
-        buttonClass: 'bg-amber-500 hover:bg-amber-600 text-white',
-      };
-    }
-    
-    return {
-      title: 'Start Incubation',
-      icon: null,
-      description: (
-        <>
-          Starting incubation begins your Blobbi's hatching journey. 
-          Complete all the tasks to hatch your egg into a baby Blobbi!
-          <br /><br />
-          Ready to begin?
-        </>
-      ),
-      buttonText: 'Start Incubation',
-      buttonClass: undefined,
-    };
-  };
-  
-  const content = getDialogContent();
-  
-  return (
-    <AlertDialog open={open} onOpenChange={onOpenChange}>
-      <AlertDialogContent>
-        <AlertDialogHeader>
-          <AlertDialogTitle className="flex items-center gap-2">
-            {content.icon}
-            {content.title}
-          </AlertDialogTitle>
-          <AlertDialogDescription>
-            {content.description}
-          </AlertDialogDescription>
-        </AlertDialogHeader>
-        <AlertDialogFooter>
-          <AlertDialogCancel disabled={isPending}>
-            Cancel
-          </AlertDialogCancel>
-          <AlertDialogAction
-            onClick={(e) => {
-              e.preventDefault();
-              handleConfirm();
-            }}
-            disabled={isPending}
-            className={content.buttonClass}
-          >
-            {isPending ? (
-              <>
-                <Loader2 className="size-4 mr-2 animate-spin" />
-                Starting...
-              </>
-            ) : (
-              content.buttonText
-            )}
-          </AlertDialogAction>
-        </AlertDialogFooter>
-      </AlertDialogContent>
-    </AlertDialog>
-  );
-}

src/blobbi/actions/components/TasksPanel.tsx

@@ -1,195 +0,0 @@
-// src/blobbi/actions/components/TasksPanel.tsx
-
-/**
- * Card-grid presentation for hatch / evolve tasks.
- *
- * Each task is a compact card in a 2-column grid.
- * Tapping a card expands it inline (full row) to reveal details.
- * Only one card is expanded at a time.
- */
-
-import { useState } from 'react';
-import { useNavigate } from 'react-router-dom';
-import {
-  Palette,
-  Droplets,
-  MessageSquare,
-  Heart,
-  UserPen,
-  Activity,
-  Loader2,
-  HelpCircle,
-} from 'lucide-react';
-import { openUrl } from '@/lib/downloadFile';
-
-import { Button } from '@/components/ui/button';
-
-import type { HatchTask } from '../hooks/useHatchTasks';
-import type { MissionCategory } from './ExpandableMissionCard';
-import {
-  ExpandableMissionCard,
-  MissionDescription,
-  MissionProgress,
-  MissionAction,
-  DynamicHint,
-} from './ExpandableMissionCard';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-interface TasksPanelProps {
-  tasks: HatchTask[];
-  allCompleted: boolean;
-  isLoading: boolean;
-  onOpenPostModal: () => void;
-  onComplete: () => void;
-  isCompleting?: boolean;
-  completeLabel: string;
-  completingLabel: string;
-  completeEmoji: string;
-  /** Mission category for styling the cards */
-  category?: MissionCategory;
-}
-
-// ─── Task Icon Mapping ────────────────────────────────────────────────────────
-
-/** Map task ids to lucide icons. Falls back to a generic icon. */
-function TaskIcon({ taskId }: { taskId: string }) {
-  const iconClass = 'size-5';
-
-  switch (taskId) {
-    case 'create_themes':
-      return <Palette className={iconClass} />;
-    case 'color_moments':
-      return <Droplets className={iconClass} />;
-    case 'create_posts':
-      return <MessageSquare className={iconClass} />;
-    case 'interactions':
-      return <Heart className={iconClass} />;
-    case 'edit_profile':
-      return <UserPen className={iconClass} />;
-    case 'maintain_stats':
-      return <Activity className={iconClass} />;
-    default:
-      return <HelpCircle className={iconClass} />;
-  }
-}
-
-// ─── Main Component ───────────────────────────────────────────────────────────
-
-export function TasksPanel({
-  tasks,
-  allCompleted,
-  isLoading,
-  onOpenPostModal,
-  onComplete,
-  isCompleting = false,
-  completeLabel,
-  completingLabel,
-  completeEmoji,
-  category = 'hatch',
-}: TasksPanelProps) {
-  const [expandedId, setExpandedId] = useState<string | null>(null);
-  const navigate = useNavigate();
-
-  const handleToggle = (id: string) => {
-    setExpandedId((prev) => (prev === id ? null : id));
-  };
-
-  if (isLoading) {
-    return (
-      <div className="flex items-center justify-center py-8">
-        <Loader2 className="size-5 animate-spin text-muted-foreground" />
-      </div>
-    );
-  }
-
-  return (
-    <div className="space-y-3">
-      {/* Card grid */}
-      <div className="grid grid-cols-2 sm:grid-cols-3 gap-2">
-        {tasks.map((task) => {
-          const isDynamic = task.type === 'dynamic';
-          const progress =
-            task.required > 0 ? task.current / task.required : task.completed ? 1 : 0;
-
-          const handleAction = () => {
-            if (!task.action || !task.actionTarget) return;
-            switch (task.action) {
-              case 'navigate':
-                navigate(task.actionTarget);
-                break;
-              case 'external_link':
-                openUrl(task.actionTarget);
-                break;
-              case 'open_modal':
-                if (task.actionTarget === 'blobbi_post') onOpenPostModal();
-                break;
-            }
-          };
-
-          return (
-            <ExpandableMissionCard
-              key={task.id}
-              id={task.id}
-              category={category}
-              icon={<TaskIcon taskId={task.id} />}
-              title={task.name}
-              completed={task.completed}
-              progress={Math.min(progress, 1)}
-              isExpanded={expandedId === task.id}
-              onToggle={handleToggle}
-            >
-              {/* Expanded content */}
-              <MissionDescription>{task.description}</MissionDescription>
-
-              {/* Progress bar for multi-step tasks */}
-              {task.required > 1 && !isDynamic && (
-                <MissionProgress
-                  current={task.current}
-                  required={task.required}
-                  completed={task.completed}
-                />
-              )}
-
-              {/* Dynamic stat hint */}
-              {isDynamic && !task.completed && (
-                <DynamicHint current={task.current} required={task.required} />
-              )}
-
-              {/* Action link */}
-              {task.action && task.actionLabel && !task.completed && (
-                <MissionAction
-                  label={task.actionLabel}
-                  type={task.action}
-                  onClick={handleAction}
-                />
-              )}
-            </ExpandableMissionCard>
-          );
-        })}
-      </div>
-
-      {/* CTA button when all tasks are done */}
-      {allCompleted && (
-        <Button
-          onClick={onComplete}
-          disabled={isCompleting}
-          size="lg"
-          className="w-full gap-2 bg-gradient-to-r from-amber-500 to-orange-500 hover:from-amber-600 hover:to-orange-600 text-white shadow-sm"
-        >
-          {isCompleting ? (
-            <>
-              <Loader2 className="size-5 animate-spin" />
-              {completingLabel}
-            </>
-          ) : (
-            <>
-              <span className="text-lg">{completeEmoji}</span>
-              {completeLabel}
-            </>
-          )}
-        </Button>
-      )}
-    </div>
-  );
-}

src/blobbi/actions/hooks/useActiveTaskProcess.ts

@@ -1,232 +0,0 @@
-// src/blobbi/actions/hooks/useActiveTaskProcess.ts
-
-/**
- * Central abstraction for the active task process (hatch or evolve).
- * 
- * This hook consolidates all scattered if/else logic for determining:
- * - Which process is active (incubating vs evolving)
- * - Which tasks to use (hatch vs evolve)
- * - Thresholds and configuration
- * - Badge-related computed values
- * 
- * ARCHITECTURE RULES:
- * - Computed tasks remain the source of truth
- * - Tags are cache only for PERSISTENT tasks
- * - Dynamic tasks are NEVER persisted
- * - Badge counts ALL incomplete tasks (persistent + dynamic)
- */
-
-import { useMemo } from 'react';
-import type { BlobbiCompanion } from '@/blobbi/core/lib/blobbi';
-import type { HatchTask, HatchTasksResult } from './useHatchTasks';
-import type { EvolveTasksResult } from './useEvolveTasks';
-import { HATCH_REQUIRED_INTERACTIONS } from './useHatchTasks';
-import { EVOLVE_REQUIRED_INTERACTIONS } from './useEvolveTasks';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-/** The type of task process currently active */
-export type TaskProcessType = 'hatch' | 'evolve' | null;
-
-/**
- * Configuration for the active task process.
- * This provides a unified interface regardless of whether
- * the process is hatch or evolve.
- */
-export interface TaskProcessConfig {
-  /** The type of process ('hatch' | 'evolve' | null) */
-  type: TaskProcessType;
-  /** Whether there is an active task process */
-  isActive: boolean;
-  /** Required interactions threshold for the current process */
-  interactionThreshold: number;
-}
-
-/**
- * Result of the active task process hook.
- * Provides unified access to all task-related state.
- */
-export interface ActiveTaskProcessResult {
-  /** Configuration for the current process */
-  config: TaskProcessConfig;
-  
-  /** All tasks for the current process (empty if no active process) */
-  tasks: HatchTask[];
-  /** Whether tasks are still loading */
-  isLoading: boolean;
-  /** Whether all tasks (persistent + dynamic) are complete */
-  allCompleted: boolean;
-  /** Whether all persistent tasks are complete */
-  persistentTasksComplete: boolean;
-  /** Whether the dynamic task is complete */
-  dynamicTaskComplete: boolean;
-  
-  /** Refetch function for current tasks */
-  refetch: () => void;
-  
-  // ─── Badge-related computed values ───
-  
-  /** 
-   * Count of ALL remaining incomplete tasks (persistent + dynamic).
-   * This is used for the badge display.
-   * Dynamic tasks ARE counted here but are NEVER synced to tags.
-   */
-  remainingTasksCount: number;
-  
-  /**
-   * Only persistent tasks that are incomplete.
-   * Used for sync logic - dynamic tasks must NEVER be synced.
-   */
-  incompletePersistentTasks: HatchTask[];
-  
-  /**
-   * Only persistent tasks that are complete.
-   * Used for sync logic.
-   */
-  completedPersistentTasks: HatchTask[];
-  
-  /**
-   * Stable string key of completed persistent task IDs.
-   * Used for sync anti-loop protection.
-   */
-  completedPersistentTaskIds: string;
-  
-  /**
-   * Tasks to sync (persistent only, with completion status).
-   * Dynamic tasks are excluded.
-   */
-  tasksToSync: Array<{ taskId: string; completed: boolean }>;
-}
-
-// ─── Helper Functions ─────────────────────────────────────────────────────────
-
-/**
- * Filter tasks to only persistent tasks.
- * Dynamic tasks must NEVER be synced to tags.
- */
-export function filterPersistentTasks(tasks: HatchTask[]): HatchTask[] {
-  return tasks.filter(t => t.type === 'persistent');
-}
-
-/**
- * Filter tasks to only dynamic tasks.
- */
-export function filterDynamicTasks(tasks: HatchTask[]): HatchTask[] {
-  return tasks.filter(t => t.type === 'dynamic');
-}
-
-// ─── Main Hook ────────────────────────────────────────────────────────────────
-
-/**
- * Hook that provides a unified interface for the active task process.
- * 
- * Usage:
- * ```ts
- * const taskProcess = useActiveTaskProcess(companion, hatchTasks, evolveTasks);
- * 
- * // Access unified data
- * taskProcess.config.type // 'hatch' | 'evolve' | null
- * taskProcess.tasks // current tasks
- * taskProcess.remainingTasksCount // for badge (includes dynamic)
- * taskProcess.tasksToSync // for sync (excludes dynamic)
- * ```
- */
-export function useActiveTaskProcess(
-  companion: BlobbiCompanion | null,
-  hatchTasks: HatchTasksResult,
-  evolveTasks: EvolveTasksResult
-): ActiveTaskProcessResult {
-  // Determine which process is active
-  const processType = useMemo((): TaskProcessType => {
-    if (!companion) return null;
-    if (companion.state === 'incubating') return 'hatch';
-    if (companion.state === 'evolving') return 'evolve';
-    return null;
-  }, [companion]);
-  
-  // Build configuration
-  const config = useMemo((): TaskProcessConfig => {
-    const isActive = processType !== null;
-    const interactionThreshold = processType === 'hatch' 
-      ? HATCH_REQUIRED_INTERACTIONS 
-      : processType === 'evolve' 
-        ? EVOLVE_REQUIRED_INTERACTIONS 
-        : 0;
-    
-    return {
-      type: processType,
-      isActive,
-      interactionThreshold,
-    };
-  }, [processType]);
-  
-  // Get the active tasks result based on process type
-  const activeResult = useMemo(() => {
-    if (processType === 'hatch') return hatchTasks;
-    if (processType === 'evolve') return evolveTasks;
-    return null;
-  }, [processType, hatchTasks, evolveTasks]);
-  
-  // Extract tasks and state from active result
-  const tasks = useMemo(() => activeResult?.tasks ?? [], [activeResult]);
-  const isLoading = activeResult?.isLoading ?? false;
-  const allCompleted = activeResult?.allCompleted ?? false;
-  const persistentTasksComplete = activeResult?.persistentTasksComplete ?? false;
-  const dynamicTaskComplete = activeResult?.dynamicTaskComplete ?? false;
-  const refetch = activeResult?.refetch ?? (() => {});
-  
-  // Compute persistent task list (dynamic tasks computed for badge count directly from tasks array)
-  const persistentTasks = useMemo(() => filterPersistentTasks(tasks), [tasks]);
-  
-  // Compute incomplete tasks (for badge - includes BOTH persistent and dynamic)
-  const remainingTasksCount = useMemo(() => {
-    // Count ALL incomplete tasks - persistent AND dynamic
-    // Dynamic tasks are included in badge count but NEVER synced to tags
-    return tasks.filter(t => !t.completed).length;
-  }, [tasks]);
-  
-  // Compute persistent task lists for sync
-  const incompletePersistentTasks = useMemo(() => 
-    persistentTasks.filter(t => !t.completed), 
-    [persistentTasks]
-  );
-  
-  const completedPersistentTasks = useMemo(() => 
-    persistentTasks.filter(t => t.completed), 
-    [persistentTasks]
-  );
-  
-  // Compute stable string key for completed persistent tasks (anti-loop)
-  const completedPersistentTaskIds = useMemo(() => {
-    if (!completedPersistentTasks.length) return '';
-    return completedPersistentTasks
-      .map(t => t.id)
-      .sort()
-      .join(',');
-  }, [completedPersistentTasks]);
-  
-  // Compute tasks to sync (persistent only)
-  // CRITICAL: Dynamic tasks must NEVER be included here
-  const tasksToSync = useMemo(() => {
-    if (!persistentTasks.length) return [];
-    return persistentTasks.map(t => ({
-      taskId: t.id,
-      completed: t.completed,
-    }));
-  }, [persistentTasks]);
-  
-  return {
-    config,
-    tasks,
-    isLoading,
-    allCompleted,
-    persistentTasksComplete,
-    dynamicTaskComplete,
-    refetch,
-    remainingTasksCount,
-    incompletePersistentTasks,
-    completedPersistentTasks,
-    completedPersistentTaskIds,
-    tasksToSync,
-  };
-}

src/blobbi/actions/hooks/useAudioPlayback.ts

@@ -1,287 +0,0 @@
-// src/blobbi/actions/hooks/useAudioPlayback.ts
-
-import { useState, useRef, useCallback, useEffect } from 'react';
-
-/**
- * Audio playback state
- * - idle: No audio loaded
- * - loading: Audio is being loaded
- * - playing: Audio is playing
- * - paused: Audio is paused (can resume)
- * - stopped: Audio was stopped (must reload to play again)
- * - error: An error occurred
- */
-export type PlaybackState = 'idle' | 'loading' | 'playing' | 'paused' | 'stopped' | 'error';
-
-/**
- * Audio playback error info
- */
-export interface PlaybackError {
-  message: string;
-  code?: string;
-}
-
-/** Default volume level (0-1) */
-const DEFAULT_VOLUME = 0.8;
-
-/**
- * Options for the useAudioPlayback hook
- */
-export interface UseAudioPlaybackOptions {
-  /** Called when playback ends naturally */
-  onEnded?: () => void;
-  /** Called when an error occurs */
-  onError?: (error: PlaybackError) => void;
-  /** Initial volume level (0-1), defaults to 0.8 */
-  initialVolume?: number;
-}
-
-/**
- * Return type for useAudioPlayback hook
- */
-export interface UseAudioPlaybackReturn {
-  /** Current playback state */
-  state: PlaybackState;
-  /** Current error (if any) */
-  error: PlaybackError | null;
-  /** Current audio URL being played */
-  currentUrl: string | null;
-  /** Load and optionally start playing an audio URL */
-  load: (url: string, autoplay?: boolean) => void;
-  /** Play the current audio */
-  play: () => Promise<void>;
-  /** Pause the current audio */
-  pause: () => void;
-  /** Stop playback and reset */
-  stop: () => void;
-  /** Restart playback from the beginning */
-  restart: () => Promise<void>;
-  /** Toggle play/pause */
-  toggle: () => Promise<void>;
-  /** Whether audio is currently playing */
-  isPlaying: boolean;
-  /** Current volume level (0-1) */
-  volume: number;
-  /** Set volume level (0-1) */
-  setVolume: (volume: number) => void;
-  /** Cleanup function to release resources */
-  cleanup: () => void;
-}
-
-/**
- * Reusable hook for audio playback.
- * Handles Audio element lifecycle, error handling, and state management.
- */
-export function useAudioPlayback(options: UseAudioPlaybackOptions = {}): UseAudioPlaybackReturn {
-  const { onEnded, onError, initialVolume = DEFAULT_VOLUME } = options;
-  
-  const [state, setState] = useState<PlaybackState>('idle');
-  const [error, setError] = useState<PlaybackError | null>(null);
-  const [currentUrl, setCurrentUrl] = useState<string | null>(null);
-  const [volume, setVolumeState] = useState<number>(initialVolume);
-  
-  const audioRef = useRef<HTMLAudioElement | null>(null);
-  const currentUrlRef = useRef<string | null>(null);
-  const volumeRef = useRef<number>(initialVolume);
-  
-  // Cleanup audio element
-  const cleanup = useCallback(() => {
-    if (audioRef.current) {
-      audioRef.current.pause();
-      audioRef.current.onended = null;
-      audioRef.current.onerror = null;
-      audioRef.current.oncanplay = null;
-      audioRef.current.onplaying = null;
-      audioRef.current = null;
-    }
-    currentUrlRef.current = null;
-    setState('idle');
-    setCurrentUrl(null);
-    setError(null);
-  }, []);
-  
-  // Cleanup on unmount
-  useEffect(() => {
-    return () => {
-      cleanup();
-    };
-  }, [cleanup]);
-  
-  // Load audio from URL
-  const load = useCallback((url: string, autoplay = false) => {
-    // If same URL, don't reload
-    if (currentUrlRef.current === url && audioRef.current) {
-      if (autoplay) {
-        audioRef.current.play().catch(() => {});
-      }
-      return;
-    }
-    
-    // Cleanup previous audio
-    if (audioRef.current) {
-      audioRef.current.pause();
-      audioRef.current.onended = null;
-      audioRef.current.onerror = null;
-      audioRef.current.oncanplay = null;
-      audioRef.current.onplaying = null;
-    }
-    
-    setState('loading');
-    setError(null);
-    setCurrentUrl(url);
-    currentUrlRef.current = url;
-    
-    const audio = new Audio(url);
-    audio.volume = volumeRef.current; // Apply current volume to new audio
-    audioRef.current = audio;
-    
-    audio.oncanplay = () => {
-      if (autoplay) {
-        audio.play().catch((err) => {
-          const playbackError: PlaybackError = {
-            message: getPlaybackErrorMessage(err),
-            code: err.name,
-          };
-          setError(playbackError);
-          setState('error');
-          onError?.(playbackError);
-        });
-      } else {
-        setState('paused');
-      }
-    };
-    
-    audio.onplaying = () => {
-      setState('playing');
-    };
-    
-    audio.onpause = () => {
-      if (state === 'playing') {
-        setState('paused');
-      }
-    };
-    
-    audio.onended = () => {
-      setState('paused');
-      onEnded?.();
-    };
-    
-    audio.onerror = () => {
-      const playbackError: PlaybackError = {
-        message: 'Failed to load audio. The format may not be supported.',
-        code: 'MEDIA_ERR',
-      };
-      setError(playbackError);
-      setState('error');
-      onError?.(playbackError);
-    };
-    
-    // Start loading
-    audio.load();
-  }, [onEnded, onError, state]);
-  
-  // Play current audio
-  const play = useCallback(async () => {
-    if (!audioRef.current) return;
-    
-    try {
-      setError(null);
-      await audioRef.current.play();
-      setState('playing');
-    } catch (err) {
-      const playbackError: PlaybackError = {
-        message: getPlaybackErrorMessage(err),
-        code: err instanceof Error ? err.name : 'UNKNOWN',
-      };
-      setError(playbackError);
-      setState('error');
-      onError?.(playbackError);
-    }
-  }, [onError]);
-  
-  // Pause current audio
-  const pause = useCallback(() => {
-    if (!audioRef.current) return;
-    audioRef.current.pause();
-    setState('paused');
-  }, []);
-  
-  // Stop playback completely (requires reload to play again)
-  const stop = useCallback(() => {
-    if (!audioRef.current) return;
-    audioRef.current.pause();
-    audioRef.current.currentTime = 0;
-    // Clear URL ref so next load() will actually reload
-    currentUrlRef.current = null;
-    setState('stopped');
-  }, []);
-  
-  // Restart playback from the beginning
-  const restart = useCallback(async () => {
-    if (!audioRef.current) return;
-    audioRef.current.currentTime = 0;
-    try {
-      await audioRef.current.play();
-      setState('playing');
-    } catch (err) {
-      const playbackError: PlaybackError = {
-        message: getPlaybackErrorMessage(err),
-        code: err instanceof Error ? err.name : 'UNKNOWN',
-      };
-      setError(playbackError);
-      setState('error');
-      onError?.(playbackError);
-    }
-  }, [onError]);
-  
-  // Toggle play/pause
-  const toggle = useCallback(async () => {
-    if (state === 'playing') {
-      pause();
-    } else {
-      await play();
-    }
-  }, [state, play, pause]);
-  
-  // Set volume (0-1)
-  const setVolume = useCallback((newVolume: number) => {
-    const clampedVolume = Math.max(0, Math.min(1, newVolume));
-    volumeRef.current = clampedVolume;
-    setVolumeState(clampedVolume);
-    if (audioRef.current) {
-      audioRef.current.volume = clampedVolume;
-    }
-  }, []);
-  
-  return {
-    state,
-    error,
-    currentUrl,
-    load,
-    play,
-    pause,
-    stop,
-    restart,
-    toggle,
-    isPlaying: state === 'playing',
-    volume,
-    setVolume,
-    cleanup,
-  };
-}
-
-/**
- * Get a user-friendly error message for playback errors
- */
-function getPlaybackErrorMessage(err: unknown): string {
-  if (err instanceof Error) {
-    if (err.name === 'NotSupportedError') {
-      return 'This audio format is not supported by your browser.';
-    }
-    if (err.name === 'NotAllowedError') {
-      return 'Playback was blocked. Try interacting with the page first.';
-    }
-    return err.message;
-  }
-  return 'An unknown error occurred during playback.';
-}

src/blobbi/actions/hooks/useBlobbiCareActivity.ts

@@ -1,200 +0,0 @@
-/**
- * useBlobbiCareActivity - Hook for registering care activity and updating streaks
- * 
- * This hook provides a centralized way to register care activity for a Blobbi companion.
- * It handles:
- * - Calculating streak updates based on the last activity day
- * - Publishing updated Blobbi state to Nostr
- * - Updating local cache
- * 
- * Use this hook whenever care activity should count toward the streak:
- * - Opening the Blobbi page (page check-in)
- * - Performing care actions (feed, clean, play, etc.)
- * - Any other care interaction
- * 
- * The streak only increments once per calendar day, regardless of how many
- * activities are performed.
- */
-
-import { useCallback, useRef } from 'react';
-import { useNostr } from '@nostrify/react';
-import { useMutation } from '@tanstack/react-query';
-import type { NostrEvent } from '@nostrify/nostrify';
-
-import { useCurrentUser } from '@/hooks/useCurrentUser';
-import { useNostrPublish } from '@/hooks/useNostrPublish';
-
-import type { BlobbiCompanion } from '@/blobbi/core/lib/blobbi';
-import {
-  KIND_BLOBBI_STATE,
-  updateBlobbiTags,
-  isValidBlobbiEvent,
-  parseBlobbiEvent,
-} from '@/blobbi/core/lib/blobbi';
-
-import { getStreakTagUpdates, calculateStreakUpdate, type StreakUpdateResult } from '../lib/blobbi-streak';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-export interface UseBlobbiCareActivityParams {
-  companion: BlobbiCompanion | null;
-  /** Update companion event in local cache */
-  updateCompanionEvent: (event: NostrEvent) => void;
-}
-
-export interface CareActivityResult {
-  /** Whether the streak was updated */
-  wasUpdated: boolean;
-  /** The new streak value */
-  newStreak: number;
-  /** Description of what happened */
-  action: StreakUpdateResult['action'];
-}
-
-// ─── Hook ─────────────────────────────────────────────────────────────────────
-
-/**
- * Hook to register care activity and update streaks.
- * 
- * Returns a function to register activity and a mutation for the actual update.
- * The register function is idempotent - calling it multiple times on the same day
- * will only update once.
- */
-export function useBlobbiCareActivity({
-  companion,
-  updateCompanionEvent,
-}: UseBlobbiCareActivityParams) {
-  const { nostr } = useNostr();
-  const { user } = useCurrentUser();
-  const { mutateAsync: publishEvent } = useNostrPublish();
-  
-  // Track if we've already registered activity this session to avoid duplicate calls
-  // This is a performance optimization - the actual idempotency is handled by day comparison
-  const lastRegisteredDay = useRef<string | null>(null);
-
-  const mutation = useMutation({
-    mutationFn: async (): Promise<CareActivityResult> => {
-      if (!user?.pubkey) {
-        throw new Error('You must be logged in to register care activity');
-      }
-
-      if (!companion) {
-        throw new Error('No companion available');
-      }
-
-      // Fetch fresh companion from relays (read-modify-write pattern)
-      const freshEvents = await nostr.query([{
-        kinds: [KIND_BLOBBI_STATE],
-        authors: [user.pubkey],
-        '#d': [companion.d],
-      }]);
-      const freshCompanion = freshEvents
-        .filter(isValidBlobbiEvent)
-        .sort((a, b) => b.created_at - a.created_at)
-        .map(e => parseBlobbiEvent(e))
-        .find(Boolean) ?? companion;
-
-      const now = new Date();
-      
-      // Calculate what the streak update should be using fresh data
-      const result = calculateStreakUpdate(
-        freshCompanion.careStreak,
-        freshCompanion.careStreakLastDay,
-        now
-      );
-      
-      // If no update needed (same day), return early without publishing
-      if (!result.wasUpdated) {
-        return {
-          wasUpdated: false,
-          newStreak: result.newStreak,
-          action: result.action,
-        };
-      }
-      
-      // Get the tag updates using fresh data
-      const streakUpdates = getStreakTagUpdates(freshCompanion, now);
-      
-      if (!streakUpdates) {
-        // Shouldn't happen if wasUpdated is true, but handle gracefully
-        return {
-          wasUpdated: false,
-          newStreak: freshCompanion.careStreak ?? 0,
-          action: 'same_day',
-        };
-      }
-      
-      // Build updated tags from fresh data
-      const updatedTags = updateBlobbiTags(freshCompanion.allTags, streakUpdates);
-      
-      // Publish the updated event
-      const event = await publishEvent({
-        kind: KIND_BLOBBI_STATE,
-        content: freshCompanion.event.content,
-        tags: updatedTags,
-      });
-      
-      // Update local cache (optimistic — no invalidation needed)
-      updateCompanionEvent(event);
-      
-      // Update session tracker
-      lastRegisteredDay.current = result.newLastDay;
-      
-      // Log for debugging (dev only)
-      if (import.meta.env.DEV) {
-        console.log('[CareActivity] Streak updated:', {
-          action: result.action,
-          previousStreak: freshCompanion.careStreak,
-          newStreak: result.newStreak,
-          lastDay: freshCompanion.careStreakLastDay,
-          newDay: result.newLastDay,
-        });
-      }
-      
-      return {
-        wasUpdated: true,
-        newStreak: result.newStreak,
-        action: result.action,
-      };
-    },
-    onError: (error: Error) => {
-      console.error('[CareActivity] Failed to update streak:', error);
-    },
-  });
-
-  /**
-   * Register care activity. Call this when care-related activity happens.
-   * Safe to call multiple times - only updates streak once per day.
-   * 
-   * @returns Promise with the result of the activity registration
-   */
-  const registerCareActivity = useCallback(async (): Promise<CareActivityResult | null> => {
-    if (!companion) {
-      return null;
-    }
-    
-    // Quick check if we've already registered for this companion's last day (session cache)
-    // This is an optimization to avoid unnecessary mutation calls
-    if (lastRegisteredDay.current === companion.careStreakLastDay) {
-      // Already processed this day in this session, skip
-      return {
-        wasUpdated: false,
-        newStreak: companion.careStreak ?? 0,
-        action: 'same_day',
-      };
-    }
-    
-    return mutation.mutateAsync();
-  }, [companion, mutation]);
-
-  return {
-    /** Register care activity - call when page opens or care action happens */
-    registerCareActivity,
-    /** Whether an update is currently in progress */
-    isUpdating: mutation.isPending,
-    /** The last update result */
-    lastResult: mutation.data,
-    /** Any error from the last update attempt */
-    error: mutation.error,
-  };
-}

src/blobbi/actions/hooks/useBlobbiDirectAction.ts

@@ -1,216 +0,0 @@
-// src/blobbi/actions/hooks/useBlobbiDirectAction.ts
-
-import { useMutation } from '@tanstack/react-query';
-
-import { useCurrentUser } from '@/hooks/useCurrentUser';
-import { useNostrPublish } from '@/hooks/useNostrPublish';
-import { toast } from '@/hooks/useToast';
-
-import type { BlobbiCompanion } from '@/blobbi/core/lib/blobbi';
-import {
-  KIND_BLOBBI_STATE,
-  updateBlobbiTags,
-} from '@/blobbi/core/lib/blobbi';
-import { applyBlobbiDecay } from '@/blobbi/core/lib/blobbi-decay';
-import {
-  clampStat,
-  applyStat,
-  DIRECT_ACTION_METADATA,
-  incrementInteractionTaskTags,
-  type DirectAction,
-} from '../lib/blobbi-action-utils';
-import { trackMultipleDailyMissionActions } from '../lib/daily-mission-tracker';
-import type { DailyMissionAction } from '../lib/daily-missions';
-import { getStreakTagUpdates } from '../lib/blobbi-streak';
-import { calculateActionXP, applyXPGain, formatXPGain } from '../lib/blobbi-xp';
-import { HATCH_REQUIRED_INTERACTIONS } from './useHatchTasks';
-import { EVOLVE_REQUIRED_INTERACTIONS } from './useEvolveTasks';
-
-// Import NostrEvent type
-import type { NostrEvent } from '@nostrify/nostrify';
-
-/**
- * Configuration for direct action happiness effects.
- * These are the happiness deltas for each direct action.
- */
-export const DIRECT_ACTION_HAPPINESS_EFFECTS: Record<DirectAction, number> = {
-  play_music: 15,
-  sing: 20,
-};
-
-/**
- * Request payload for executing a direct action
- */
-export interface DirectActionRequest {
-  action: DirectAction;
-}
-
-/**
- * Result of executing a direct action
- */
-export interface DirectActionResult {
-  action: DirectAction;
-  happinessChange: number;
-  xpGained: number;
-  newXP: number;
-}
-
-/**
- * Parameters for the useBlobbiDirectAction hook
- */
-export interface UseBlobbiDirectActionParams {
-  companion: BlobbiCompanion | null;
-  /** Called after ensuring companion is canonical (from migration helper) */
-  ensureCanonicalBeforeAction: () => Promise<{
-    companion: BlobbiCompanion;
-    content: string;
-    allTags: string[][];
-    wasMigrated: boolean;
-  } | null>;
-  /** Update companion event in local cache */
-  updateCompanionEvent: (event: NostrEvent) => void;
-}
-
-/**
- * Hook to execute a direct action on a Blobbi companion.
- * Direct actions (play_music, sing) don't require selecting an item.
- * They directly affect happiness stat.
- * 
- * This hook:
- * 1. Validates the companion exists
- * 2. Ensures canonical format before action
- * 3. Applies accumulated decay
- * 4. Applies happiness boost
- * 5. Updates Blobbi state (kind 31124)
- * 6. Invalidates relevant queries
- */
-export function useBlobbiDirectAction({
-  companion,
-  ensureCanonicalBeforeAction,
-  updateCompanionEvent,
-}: UseBlobbiDirectActionParams) {
-  const { user } = useCurrentUser();
-  const { mutateAsync: publishEvent } = useNostrPublish();
-
-  return useMutation({
-    mutationFn: async ({ action }: DirectActionRequest): Promise<DirectActionResult> => {
-      // ─── Validation ───
-      if (!user?.pubkey) {
-        throw new Error('You must be logged in to perform actions');
-      }
-
-      if (!companion) {
-        throw new Error('No companion selected');
-      }
-
-      // ─── Ensure Canonical Before Action ───
-      const canonical = await ensureCanonicalBeforeAction();
-      if (!canonical) {
-        throw new Error('Failed to prepare companion for action');
-      }
-
-      // ─── Apply Accumulated Decay First ───
-      // CRITICAL: Use canonical.companion for decay calculations, not the stale outer companion
-      const now = Math.floor(Date.now() / 1000);
-      const decayResult = applyBlobbiDecay({
-        stage: canonical.companion.stage,
-        state: canonical.companion.state,
-        stats: canonical.companion.stats,
-        lastDecayAt: canonical.companion.lastDecayAt,
-        now,
-      });
-      
-      const statsAfterDecay = decayResult.stats;
-      
-      // ─── Apply Happiness Effect ───
-      const happinessDelta = DIRECT_ACTION_HAPPINESS_EFFECTS[action];
-      const newHappiness = applyStat(statsAfterDecay.happiness, happinessDelta);
-      
-      // Track if happiness actually changed
-      const happinessChanged = newHappiness !== statsAfterDecay.happiness;
-      
-      // Build stats update
-      const isEgg = canonical.companion.stage === 'egg';
-      const statsUpdate: Record<string, string> = {
-        happiness: newHappiness.toString(),
-        health: statsAfterDecay.health.toString(),
-        hygiene: statsAfterDecay.hygiene.toString(),
-      };
-      
-      if (isEgg) {
-        // Eggs have fixed hunger and energy
-        statsUpdate.hunger = '100';
-        statsUpdate.energy = '100';
-      } else {
-        statsUpdate.hunger = clampStat(statsAfterDecay.hunger).toString();
-        statsUpdate.energy = clampStat(statsAfterDecay.energy).toString();
-      }
-
-      // ─── Update Blobbi State Event (kind 31124) ───
-      const nowStr = now.toString();
-      
-      // If incubating or evolving, increment the interaction counter for tasks
-      const companionState = canonical.companion.state;
-      let updatedTags = canonical.allTags;
-      if (companionState === 'incubating') {
-        updatedTags = incrementInteractionTaskTags(canonical.allTags, HATCH_REQUIRED_INTERACTIONS).updatedTags;
-      } else if (companionState === 'evolving') {
-        updatedTags = incrementInteractionTaskTags(canonical.allTags, EVOLVE_REQUIRED_INTERACTIONS).updatedTags;
-      }
-      
-      // Get streak updates (will only update if needed based on day)
-      const streakUpdates = getStreakTagUpdates(canonical.companion) ?? {};
-      
-      // ─── Apply XP Gain (ONLY if happiness actually changed) ───
-      // Direct actions modify happiness. Only grant XP if happiness actually increased.
-      const xpGained = happinessChanged ? calculateActionXP(action) : 0;
-      const currentXP = canonical.companion.experience ?? 0;
-      const newXP = applyXPGain(currentXP, xpGained);
-      
-      const blobbiTags = updateBlobbiTags(updatedTags, {
-        ...statsUpdate,
-        ...streakUpdates,
-        experience: newXP.toString(),
-        last_interaction: nowStr,
-        last_decay_at: nowStr,
-      });
-
-      const blobbiEvent = await publishEvent({
-        kind: KIND_BLOBBI_STATE,
-        content: canonical.content,
-        tags: blobbiTags,
-      });
-
-      updateCompanionEvent(blobbiEvent);
-
-      return {
-        action,
-        happinessChange: happinessDelta,
-        xpGained,
-        newXP,
-      };
-    },
-    onSuccess: ({ action, happinessChange, xpGained }) => {
-      const actionMeta = DIRECT_ACTION_METADATA[action];
-      const xpText = formatXPGain(xpGained);
-      toast({
-        title: `${actionMeta.label} complete!`,
-        description: `Your Blobbi's happiness increased by ${happinessChange}! ${xpText}`,
-      });
-
-      // Track daily mission progress
-      // 'interact' is always tracked, plus the specific action
-      const dailyActions: DailyMissionAction[] = ['interact'];
-      if (action === 'sing') dailyActions.push('sing');
-      if (action === 'play_music') dailyActions.push('play_music');
-      trackMultipleDailyMissionActions(dailyActions, user?.pubkey);
-    },
-    onError: (error: Error) => {
-      toast({
-        title: 'Action failed',
-        description: error.message,
-        variant: 'destructive',
-      });
-    },
-  });
-}

src/blobbi/actions/hooks/useBlobbiIncubation.ts

@@ -1,880 +0,0 @@
-// src/blobbi/actions/hooks/useBlobbiIncubation.ts
-
-/**
- * Hooks for Blobbi incubation task system.
- * 
- * When a user starts incubation:
- * 1. Apply accumulated decay from last_decay_at to now
- * 2. Set state to 'incubating'
- * 3. Add state_started_at timestamp
- * 4. Update last_decay_at to the same timestamp
- * 5. Clear any previous task progress
- * 
- * Tasks are computed from Nostr events with created_at >= state_started_at
- */
-
-import { useMutation } from '@tanstack/react-query';
-import { useNostr } from '@nostrify/react';
-import type { NostrEvent } from '@nostrify/nostrify';
-
-import { useCurrentUser } from '@/hooks/useCurrentUser';
-import { useNostrPublish } from '@/hooks/useNostrPublish';
-import { toast } from '@/hooks/useToast';
-
-import type { BlobbiCompanion, BlobbonautProfile } from '@/blobbi/core/lib/blobbi';
-import {
-  KIND_BLOBBI_STATE,
-  updateBlobbiTags,
-} from '@/blobbi/core/lib/blobbi';
-import { applyBlobbiDecay } from '@/blobbi/core/lib/blobbi-decay';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-/**
- * Mode for starting incubation.
- * This makes the intent explicit rather than auto-detecting behavior.
- */
-export type StartIncubationMode = 
-  | 'start'              // Normal start (no other Blobbi incubating)
-  | 'restart'            // Restart same Blobbi (already incubating)
-  | 'switch';            // Switch from another incubating Blobbi
-
-/**
- * Request to start incubation with explicit mode.
- */
-export interface StartIncubationRequest {
-  /** Explicit mode for this operation */
-  mode: StartIncubationMode;
-  /** The d-tag of the other Blobbi to stop (required when mode === 'switch') */
-  stopOtherD?: string;
-}
-
-/**
- * Parameters for start incubation hook.
- */
-export interface UseStartIncubationParams {
-  companion: BlobbiCompanion | null;
-  profile: BlobbonautProfile | null;
-  /** Called to ensure companion is canonical (from migration helper) */
-  ensureCanonicalBeforeAction: () => Promise<{
-    companion: BlobbiCompanion;
-    content: string;
-    allTags: string[][];
-    wasMigrated: boolean;
-    profileAllTags: string[][];
-    profileStorage: import('@/blobbi/core/lib/blobbi').StorageItem[];
-  } | null>;
-  /** Update companion event in local cache */
-  updateCompanionEvent: (event: NostrEvent) => void;
-}
-
-/**
- * Result of starting incubation.
- */
-export interface StartIncubationResult {
-  /** The Blobbi's name */
-  name: string;
-  /** Timestamp when incubation started */
-  stateStartedAt: number;
-  /** Mode that was used */
-  mode: StartIncubationMode;
-  /** Name of other Blobbi that was stopped (if mode === 'switch') */
-  stoppedOtherName?: string;
-}
-
-// ─── Start Incubation Hook ────────────────────────────────────────────────────
-
-/**
- * Hook to start the incubation process for an egg.
- * 
- * This sets the Blobbi state to 'incubating' and records the start timestamp.
- * Tasks will be computed based on events created after this timestamp.
- * 
- * IMPORTANT: The mode must be explicitly specified by the caller (UI).
- * This hook does NOT auto-detect whether to switch or restart.
- * The UI dialog determines the mode and passes it explicitly.
- * 
- * Modes:
- * - 'start': Normal start, no other Blobbi incubating
- * - 'restart': Restart same Blobbi (already incubating), resets task progress
- * - 'switch': Stop another Blobbi first, then start this one
- * 
- * Requirements:
- * - Blobbi must be in egg stage
- * - User must be logged in
- */
-export function useStartIncubation({
-  companion,
-  profile,
-  ensureCanonicalBeforeAction,
-  updateCompanionEvent,
-}: UseStartIncubationParams) {
-  const { user } = useCurrentUser();
-  const { nostr } = useNostr();
-  const { mutateAsync: publishEvent } = useNostrPublish();
-
-  return useMutation({
-    mutationFn: async (request: StartIncubationRequest): Promise<StartIncubationResult> => {
-      const { mode, stopOtherD } = request;
-      
-      // ─── Validation ───
-      if (!user?.pubkey) {
-        throw new Error('You must be logged in to start incubation');
-      }
-
-      if (!companion) {
-        throw new Error('No companion selected');
-      }
-
-      if (!profile) {
-        throw new Error('Profile not found');
-      }
-
-      if (companion.stage !== 'egg') {
-        throw new Error('Only eggs can be incubated');
-      }
-
-      // Validate switch mode requires stopOtherD
-      if (mode === 'switch' && !stopOtherD) {
-        throw new Error('Switch mode requires stopOtherD parameter');
-      }
-
-      let stoppedOtherName: string | undefined;
-
-      // ─── Stop Other Incubating Blobbi (switch mode only) ───
-      if (mode === 'switch' && stopOtherD) {
-        // Fetch the current event for the other Blobbi
-        const [otherEvent] = await nostr.query([{
-          kinds: [KIND_BLOBBI_STATE],
-          authors: [user.pubkey],
-          '#d': [stopOtherD],
-          limit: 1,
-        }]);
-        
-        if (otherEvent) {
-          // Get name from the event for the result
-          const nameTag = otherEvent.tags.find(t => t[0] === 'name');
-          stoppedOtherName = nameTag?.[1] ?? stopOtherD;
-          
-          // Stop the other Blobbi's incubation
-          const now = Math.floor(Date.now() / 1000);
-          const nowStr = now.toString();
-          
-          // Parse stats from the event
-          const getTagValue = (tags: string[][], name: string): number => 
-            parseInt(tags.find(t => t[0] === name)?.[1] ?? '50', 10);
-          
-          const otherStats = {
-            hunger: getTagValue(otherEvent.tags, 'hunger'),
-            happiness: getTagValue(otherEvent.tags, 'happiness'),
-            health: getTagValue(otherEvent.tags, 'health'),
-            hygiene: getTagValue(otherEvent.tags, 'hygiene'),
-            energy: getTagValue(otherEvent.tags, 'energy'),
-          };
-          const otherLastDecayAt = getTagValue(otherEvent.tags, 'last_decay_at') || now;
-          
-          // Apply decay to the other Blobbi
-          const otherDecayResult = applyBlobbiDecay({
-            stage: 'egg',
-            state: 'incubating',
-            stats: otherStats,
-            lastDecayAt: otherLastDecayAt,
-            now,
-          });
-          
-          // Remove task tags and state_started_at from the other Blobbi
-          const otherCleanedTags = otherEvent.tags.filter(tag => 
-            tag[0] !== 'task' && 
-            tag[0] !== 'task_completed' && 
-            tag[0] !== 'state_started_at'
-          );
-          
-          const otherNewTags = updateBlobbiTags(otherCleanedTags, {
-            health: otherDecayResult.stats.health.toString(),
-            hygiene: otherDecayResult.stats.hygiene.toString(),
-            happiness: otherDecayResult.stats.happiness.toString(),
-            hunger: '100',
-            energy: '100',
-            state: 'active',
-            last_interaction: nowStr,
-            last_decay_at: nowStr,
-          });
-          
-          // Publish the stop event for the other Blobbi
-          const stopEvent = await publishEvent({
-            kind: KIND_BLOBBI_STATE,
-            content: otherEvent.content,
-            tags: otherNewTags,
-          });
-          
-          // Update the cache for the stopped Blobbi
-          updateCompanionEvent(stopEvent);
-        }
-      }
-
-      // ─── Ensure Canonical Before Action ───
-      const canonical = await ensureCanonicalBeforeAction();
-      if (!canonical) {
-        throw new Error('Failed to prepare companion for incubation');
-      }
-
-      // ─── Apply Accumulated Decay ───
-      // CRITICAL: Apply decay from last_decay_at to now before changing state
-      const now = Math.floor(Date.now() / 1000);
-      const nowStr = now.toString();
-      
-      const decayResult = applyBlobbiDecay({
-        stage: canonical.companion.stage,
-        state: canonical.companion.state,
-        stats: canonical.companion.stats,
-        lastDecayAt: canonical.companion.lastDecayAt,
-        now,
-      });
-      
-      // ─── Build Updated Tags ───
-      // Remove any existing task tags when starting fresh (for all modes)
-      const cleanedTags = canonical.allTags.filter(tag => 
-        tag[0] !== 'task' && tag[0] !== 'task_completed'
-      );
-      
-      // Build stats update with decayed values
-      // Eggs have fixed hunger and energy at 100
-      const statsUpdate: Record<string, string> = {
-        health: decayResult.stats.health.toString(),
-        hygiene: decayResult.stats.hygiene.toString(),
-        happiness: decayResult.stats.happiness.toString(),
-        hunger: '100',
-        energy: '100',
-      };
-      
-      const newTags = updateBlobbiTags(cleanedTags, {
-        ...statsUpdate,
-        state: 'incubating',
-        state_started_at: nowStr,
-        last_interaction: nowStr,
-        last_decay_at: nowStr,
-      });
-
-      // ─── Publish Event ───
-      const event = await publishEvent({
-        kind: KIND_BLOBBI_STATE,
-        content: canonical.content,
-        tags: newTags,
-      });
-
-      updateCompanionEvent(event);
-
-      return {
-        name: canonical.companion.name,
-        stateStartedAt: now,
-        mode,
-        stoppedOtherName,
-      };
-    },
-    onSuccess: ({ name, mode, stoppedOtherName }) => {
-      if (mode === 'switch' && stoppedOtherName) {
-        toast({
-          title: 'Switched incubation!',
-          description: `Stopped ${stoppedOtherName}, now incubating ${name}.`,
-        });
-      } else if (mode === 'restart') {
-        toast({
-          title: 'Incubation restarted!',
-          description: `${name}'s task progress has been reset.`,
-        });
-      } else {
-        toast({
-          title: 'Incubation started!',
-          description: `${name} is now incubating. Complete the tasks to hatch!`,
-        });
-      }
-    },
-    onError: (error: Error) => {
-      toast({
-        title: 'Failed to start incubation',
-        description: error.message,
-        variant: 'destructive',
-      });
-    },
-  });
-}
-
-// ─── Stop Incubation Hook ─────────────────────────────────────────────────────
-
-/**
- * Parameters for stop incubation hook.
- */
-export interface UseStopIncubationParams {
-  companion: BlobbiCompanion | null;
-  /** Called to ensure companion is canonical (from migration helper) */
-  ensureCanonicalBeforeAction: () => Promise<{
-    companion: BlobbiCompanion;
-    content: string;
-    allTags: string[][];
-    wasMigrated: boolean;
-    profileAllTags: string[][];
-    profileStorage: import('@/blobbi/core/lib/blobbi').StorageItem[];
-  } | null>;
-  /** Update companion event in local cache */
-  updateCompanionEvent: (event: NostrEvent) => void;
-}
-
-/**
- * Result of stopping incubation.
- */
-export interface StopIncubationResult {
-  /** The Blobbi's name */
-  name: string;
-}
-
-/**
- * Hook to stop/cancel the incubation process for a Blobbi.
- * 
- * This resets the Blobbi state to 'active' and clears all task progress tags.
- * The user can restart incubation later, but will need to complete tasks again.
- * 
- * When stopping incubation:
- * - Apply accumulated decay first
- * - Set state back to 'active'
- * - Remove state_started_at tag
- * - Remove all task and task_completed tags
- * 
- * Requirements:
- * - Blobbi must be in incubating state
- * - User must be logged in
- */
-export function useStopIncubation({
-  companion,
-  ensureCanonicalBeforeAction,
-  updateCompanionEvent,
-}: UseStopIncubationParams) {
-  const { user } = useCurrentUser();
-  const { mutateAsync: publishEvent } = useNostrPublish();
-
-  return useMutation({
-    mutationFn: async (): Promise<StopIncubationResult> => {
-      // ─── Validation ───
-      if (!user?.pubkey) {
-        throw new Error('You must be logged in to stop incubation');
-      }
-
-      if (!companion) {
-        throw new Error('No companion selected');
-      }
-
-      if (companion.state !== 'incubating') {
-        throw new Error('This Blobbi is not incubating');
-      }
-
-      // ─── Ensure Canonical Before Action ───
-      const canonical = await ensureCanonicalBeforeAction();
-      if (!canonical) {
-        throw new Error('Failed to prepare companion');
-      }
-
-      // ─── Apply Accumulated Decay ───
-      const now = Math.floor(Date.now() / 1000);
-      const nowStr = now.toString();
-      
-      const decayResult = applyBlobbiDecay({
-        stage: canonical.companion.stage,
-        state: canonical.companion.state,
-        stats: canonical.companion.stats,
-        lastDecayAt: canonical.companion.lastDecayAt,
-        now,
-      });
-      
-      // ─── Build Updated Tags ───
-      // Remove task tags and state_started_at
-      const cleanedTags = canonical.allTags.filter(tag => 
-        tag[0] !== 'task' && 
-        tag[0] !== 'task_completed' && 
-        tag[0] !== 'state_started_at'
-      );
-      
-      // Build stats update with decayed values
-      // Eggs have fixed hunger and energy at 100
-      const statsUpdate: Record<string, string> = {
-        health: decayResult.stats.health.toString(),
-        hygiene: decayResult.stats.hygiene.toString(),
-        happiness: decayResult.stats.happiness.toString(),
-        hunger: '100',
-        energy: '100',
-      };
-      
-      const newTags = updateBlobbiTags(cleanedTags, {
-        ...statsUpdate,
-        state: 'active',
-        last_interaction: nowStr,
-        last_decay_at: nowStr,
-      });
-
-      // ─── Publish Event ───
-      const event = await publishEvent({
-        kind: KIND_BLOBBI_STATE,
-        content: canonical.content,
-        tags: newTags,
-      });
-
-      updateCompanionEvent(event);
-
-      return {
-        name: canonical.companion.name,
-      };
-    },
-    onSuccess: ({ name }) => {
-      toast({
-        title: 'Incubation stopped',
-        description: `${name} is no longer incubating. Task progress has been reset.`,
-      });
-    },
-    onError: (error: Error) => {
-      toast({
-        title: 'Failed to stop incubation',
-        description: error.message,
-        variant: 'destructive',
-      });
-    },
-  });
-}
-
-// ─── Start Evolution Hook ─────────────────────────────────────────────────────
-
-/**
- * Parameters for start evolution hook.
- */
-export interface UseStartEvolutionParams {
-  companion: BlobbiCompanion | null;
-  /** Called to ensure companion is canonical (from migration helper) */
-  ensureCanonicalBeforeAction: () => Promise<{
-    companion: BlobbiCompanion;
-    content: string;
-    allTags: string[][];
-    wasMigrated: boolean;
-    profileAllTags: string[][];
-    profileStorage: import('@/blobbi/core/lib/blobbi').StorageItem[];
-  } | null>;
-  /** Update companion event in local cache */
-  updateCompanionEvent: (event: NostrEvent) => void;
-}
-
-/**
- * Result of starting evolution.
- */
-export interface StartEvolutionResult {
-  /** The Blobbi's name */
-  name: string;
-  /** Timestamp when evolution started */
-  stateStartedAt: number;
-}
-
-/**
- * Hook to start the evolution process for a baby Blobbi.
- * 
- * This sets the Blobbi state to 'evolving' and records the start timestamp.
- * Tasks will be computed based on events created after this timestamp.
- * 
- * Requirements:
- * - Blobbi must be in baby stage
- * - Blobbi must not already be evolving
- * - User must be logged in
- */
-export function useStartEvolution({
-  companion,
-  ensureCanonicalBeforeAction,
-  updateCompanionEvent,
-}: UseStartEvolutionParams) {
-  const { user } = useCurrentUser();
-  const { mutateAsync: publishEvent } = useNostrPublish();
-
-  return useMutation({
-    mutationFn: async (): Promise<StartEvolutionResult> => {
-      // ─── Validation ───
-      if (!user?.pubkey) {
-        throw new Error('You must be logged in to start evolution');
-      }
-
-      if (!companion) {
-        throw new Error('No companion selected');
-      }
-
-      if (companion.stage !== 'baby') {
-        throw new Error('Only baby Blobbis can evolve');
-      }
-
-      if (companion.state === 'evolving') {
-        throw new Error('This Blobbi is already evolving');
-      }
-
-      // ─── Ensure Canonical Before Action ───
-      const canonical = await ensureCanonicalBeforeAction();
-      if (!canonical) {
-        throw new Error('Failed to prepare companion for evolution');
-      }
-
-      // ─── Apply Accumulated Decay ───
-      const now = Math.floor(Date.now() / 1000);
-      const nowStr = now.toString();
-      
-      const decayResult = applyBlobbiDecay({
-        stage: canonical.companion.stage,
-        state: canonical.companion.state,
-        stats: canonical.companion.stats,
-        lastDecayAt: canonical.companion.lastDecayAt,
-        now,
-      });
-      
-      // ─── Build Updated Tags ───
-      // Remove any existing task tags when starting fresh
-      const cleanedTags = canonical.allTags.filter(tag => 
-        tag[0] !== 'task' && tag[0] !== 'task_completed'
-      );
-      
-      // Build stats update with decayed values
-      const statsUpdate: Record<string, string> = {
-        health: decayResult.stats.health.toString(),
-        hygiene: decayResult.stats.hygiene.toString(),
-        happiness: decayResult.stats.happiness.toString(),
-        hunger: decayResult.stats.hunger.toString(),
-        energy: decayResult.stats.energy.toString(),
-      };
-      
-      const newTags = updateBlobbiTags(cleanedTags, {
-        ...statsUpdate,
-        state: 'evolving',
-        state_started_at: nowStr,
-        last_interaction: nowStr,
-        last_decay_at: nowStr,
-      });
-
-      // ─── Publish Event ───
-      const event = await publishEvent({
-        kind: KIND_BLOBBI_STATE,
-        content: canonical.content,
-        tags: newTags,
-      });
-
-      updateCompanionEvent(event);
-
-      return {
-        name: canonical.companion.name,
-        stateStartedAt: now,
-      };
-    },
-    onSuccess: ({ name }) => {
-      toast({
-        title: 'Evolution started!',
-        description: `${name} is now working towards evolution. Complete the tasks to evolve!`,
-      });
-    },
-    onError: (error: Error) => {
-      toast({
-        title: 'Failed to start evolution',
-        description: error.message,
-        variant: 'destructive',
-      });
-    },
-  });
-}
-
-// ─── Stop Evolution Hook ──────────────────────────────────────────────────────
-
-/**
- * Parameters for stop evolution hook.
- */
-export interface UseStopEvolutionParams {
-  companion: BlobbiCompanion | null;
-  /** Called to ensure companion is canonical (from migration helper) */
-  ensureCanonicalBeforeAction: () => Promise<{
-    companion: BlobbiCompanion;
-    content: string;
-    allTags: string[][];
-    wasMigrated: boolean;
-    profileAllTags: string[][];
-    profileStorage: import('@/blobbi/core/lib/blobbi').StorageItem[];
-  } | null>;
-  /** Update companion event in local cache */
-  updateCompanionEvent: (event: NostrEvent) => void;
-}
-
-/**
- * Result of stopping evolution.
- */
-export interface StopEvolutionResult {
-  /** The Blobbi's name */
-  name: string;
-}
-
-/**
- * Hook to stop/cancel the evolution process for a Blobbi.
- * 
- * This resets the Blobbi state to 'active' and clears all task progress tags.
- * The user can restart evolution later, but will need to complete tasks again.
- * 
- * When stopping evolution:
- * - Apply accumulated decay first
- * - Set state back to 'active'
- * - Remove state_started_at tag
- * - Remove all task and task_completed tags
- * 
- * Requirements:
- * - Blobbi must be in evolving state
- * - User must be logged in
- */
-export function useStopEvolution({
-  companion,
-  ensureCanonicalBeforeAction,
-  updateCompanionEvent,
-}: UseStopEvolutionParams) {
-  const { user } = useCurrentUser();
-  const { mutateAsync: publishEvent } = useNostrPublish();
-
-  return useMutation({
-    mutationFn: async (): Promise<StopEvolutionResult> => {
-      // ─── Validation ───
-      if (!user?.pubkey) {
-        throw new Error('You must be logged in to stop evolution');
-      }
-
-      if (!companion) {
-        throw new Error('No companion selected');
-      }
-
-      if (companion.state !== 'evolving') {
-        throw new Error('This Blobbi is not evolving');
-      }
-
-      // ─── Ensure Canonical Before Action ───
-      const canonical = await ensureCanonicalBeforeAction();
-      if (!canonical) {
-        throw new Error('Failed to prepare companion');
-      }
-
-      // ─── Apply Accumulated Decay ───
-      const now = Math.floor(Date.now() / 1000);
-      const nowStr = now.toString();
-      
-      const decayResult = applyBlobbiDecay({
-        stage: canonical.companion.stage,
-        state: canonical.companion.state,
-        stats: canonical.companion.stats,
-        lastDecayAt: canonical.companion.lastDecayAt,
-        now,
-      });
-      
-      // ─── Build Updated Tags ───
-      // Remove task tags and state_started_at
-      const cleanedTags = canonical.allTags.filter(tag => 
-        tag[0] !== 'task' && 
-        tag[0] !== 'task_completed' && 
-        tag[0] !== 'state_started_at'
-      );
-      
-      // Build stats update with decayed values
-      const statsUpdate: Record<string, string> = {
-        health: decayResult.stats.health.toString(),
-        hygiene: decayResult.stats.hygiene.toString(),
-        happiness: decayResult.stats.happiness.toString(),
-        hunger: decayResult.stats.hunger.toString(),
-        energy: decayResult.stats.energy.toString(),
-      };
-      
-      const newTags = updateBlobbiTags(cleanedTags, {
-        ...statsUpdate,
-        state: 'active',
-        last_interaction: nowStr,
-        last_decay_at: nowStr,
-      });
-
-      // ─── Publish Event ───
-      const event = await publishEvent({
-        kind: KIND_BLOBBI_STATE,
-        content: canonical.content,
-        tags: newTags,
-      });
-
-      updateCompanionEvent(event);
-
-      return {
-        name: canonical.companion.name,
-      };
-    },
-    onSuccess: ({ name }) => {
-      toast({
-        title: 'Evolution stopped',
-        description: `${name} is no longer evolving. Task progress has been reset.`,
-      });
-    },
-    onError: (error: Error) => {
-      toast({
-        title: 'Failed to stop evolution',
-        description: error.message,
-        variant: 'destructive',
-      });
-    },
-  });
-}
-
-// ─── Sync Task Completions Hook ───────────────────────────────────────────────
-
-/** Enable debug logging in development only */
-const DEBUG_TASK_SYNC = import.meta.env.DEV;
-
-/**
- * Parameters for syncing task completions (works for both hatch and evolve).
- */
-export interface UseSyncTaskCompletionsParams {
-  companion: BlobbiCompanion | null;
-  /** Called to ensure companion is canonical */
-  ensureCanonicalBeforeAction: () => Promise<{
-    companion: BlobbiCompanion;
-    content: string;
-    allTags: string[][];
-    wasMigrated: boolean;
-    profileAllTags: string[][];
-    profileStorage: import('@/blobbi/core/lib/blobbi').StorageItem[];
-  } | null>;
-  /** Update companion event in local cache */
-  updateCompanionEvent: (event: NostrEvent) => void;
-}
-
-/**
- * Task completions to sync (from useHatchTasks or useEvolveTasks).
- */
-export interface TaskCompletionToSync {
-  taskId: string;
-  completed: boolean;
-}
-
-/**
- * Result of sync operation.
- */
-export interface SyncTaskCompletionsResult {
-  /** Task IDs that were synced (empty if nothing needed) */
-  synced: string[];
-  /** Whether sync was skipped (no diff) */
-  skipped: boolean;
-  /** Reason for skip (for debugging) */
-  skipReason?: string;
-}
-
-/**
- * Hook to sync persistent task completions to kind 31124 tags.
- * Works for both hatch (incubating) and evolve (evolving) processes.
- * 
- * CRITICAL: This is a cache-only sync. It must be:
- * 1. Fully idempotent - calling multiple times with same data = no-op
- * 2. Diff-based - only publish when tags would actually change
- * 3. Safe - no last_interaction update (this is cache sync, not user action)
- * 4. Only sync PERSISTENT tasks - dynamic tasks must NEVER be synced
- * 
- * Source of truth = computed task state from Nostr events.
- * Tags = cache layer for faster access.
- */
-export function useSyncTaskCompletions({
-  companion,
-  ensureCanonicalBeforeAction,
-  updateCompanionEvent,
-}: UseSyncTaskCompletionsParams) {
-  const { user } = useCurrentUser();
-  const { mutateAsync: publishEvent } = useNostrPublish();
-
-  return useMutation({
-    mutationFn: async (tasksToSync: TaskCompletionToSync[]): Promise<SyncTaskCompletionsResult> => {
-      // ─── Early Guards ───
-      if (!user?.pubkey) {
-        return { synced: [], skipped: true, skipReason: 'no_user' };
-      }
-
-      if (!companion) {
-        return { synced: [], skipped: true, skipReason: 'no_companion' };
-      }
-
-      // Must be in an active task process (incubating or evolving)
-      if (companion.state !== 'incubating' && companion.state !== 'evolving') {
-        return { synced: [], skipped: true, skipReason: 'not_in_task_process' };
-      }
-
-      // ─── Compute Diff ───
-      // Get cached completions from companion.tasksCompleted (parsed from tags)
-      const cachedCompletions = new Set(companion.tasksCompleted);
-      
-      // Get computed completions from tasks (works for both hatch and evolve)
-      const computedCompletions = tasksToSync
-        .filter(t => t.completed)
-        .map(t => t.taskId);
-      
-      // Find tasks that are computed as complete but NOT in cache
-      const missingFromCache = computedCompletions.filter(id => !cachedCompletions.has(id));
-
-      if (DEBUG_TASK_SYNC) {
-        console.log('[TaskSync] Diff check:', {
-          cachedCompletions: Array.from(cachedCompletions),
-          computedCompletions,
-          missingFromCache,
-        });
-      }
-
-      // If no diff, skip entirely
-      if (missingFromCache.length === 0) {
-        if (DEBUG_TASK_SYNC) {
-          console.log('[TaskSync] Skipped: no diff between computed and cached');
-        }
-        return { synced: [], skipped: true, skipReason: 'no_diff' };
-      }
-
-      // ─── Ensure Canonical ───
-      const canonical = await ensureCanonicalBeforeAction();
-      if (!canonical) {
-        return { synced: [], skipped: true, skipReason: 'canonical_failed' };
-      }
-
-      // ─── Build Updated Tags ───
-      // Re-check against canonical.allTags (may have updated since companion was parsed)
-      const existingCompletionTags = new Set(
-        canonical.allTags
-          .filter(tag => tag[0] === 'task_completed')
-          .map(tag => tag[1])
-      );
-
-      // Filter to only truly missing tags
-      const tagsToAdd = missingFromCache.filter(id => !existingCompletionTags.has(id));
-
-      if (tagsToAdd.length === 0) {
-        if (DEBUG_TASK_SYNC) {
-          console.log('[TaskSync] Skipped: all tags already exist in canonical');
-        }
-        return { synced: [], skipped: true, skipReason: 'tags_already_exist' };
-      }
-
-      // Add only the missing task_completed tags
-      // CRITICAL: Do NOT update last_interaction - this is cache sync, not user action
-      const updatedTags = [
-        ...canonical.allTags,
-        ...tagsToAdd.map(id => ['task_completed', id]),
-      ];
-
-      if (DEBUG_TASK_SYNC) {
-        console.log('[TaskSync] Publishing:', {
-          tagsToAdd,
-          totalTags: updatedTags.length,
-        });
-      }
-
-      // ─── Publish ───
-      const event = await publishEvent({
-        kind: KIND_BLOBBI_STATE,
-        content: canonical.content,
-        tags: updatedTags,
-      });
-
-      updateCompanionEvent(event);
-
-      if (DEBUG_TASK_SYNC) {
-        console.log('[TaskSync] Published successfully:', tagsToAdd);
-      }
-
-      return { synced: tagsToAdd, skipped: false };
-    },
-  });
-}

src/blobbi/actions/hooks/useBlobbiStageTransition.ts

@@ -1,387 +0,0 @@
-// src/blobbi/actions/hooks/useBlobbiStageTransition.ts
-
-/**
- * Hooks for Blobbi stage transitions (hatch, evolve).
- * 
- * Both transitions follow the same decay pattern:
- * 1. Apply accumulated decay from `last_decay_at` to `now`
- * 2. Use decayed stats as the source of truth for the transition
- * 3. Publish new event with decayed stats + new stage
- * 4. Reset `last_decay_at` to current timestamp
- * 
- * @see docs/blobbi/decay-system.md
- */
-
-import { useMutation } from '@tanstack/react-query';
-import type { NostrEvent } from '@nostrify/nostrify';
-
-import { useCurrentUser } from '@/hooks/useCurrentUser';
-import { useNostrPublish } from '@/hooks/useNostrPublish';
-import { toast } from '@/hooks/useToast';
-
-import type { BlobbiCompanion, BlobbonautProfile, BlobbiStage } from '@/blobbi/core/lib/blobbi';
-import {
-  KIND_BLOBBI_STATE,
-  STAT_MAX,
-  updateBlobbiTags,
-} from '@/blobbi/core/lib/blobbi';
-import { applyBlobbiDecay } from '@/blobbi/core/lib/blobbi-decay';
-import { validateAndRepairBlobbiTags } from '@/blobbi/core/lib/blobbi-tag-schema';
-import { getStreakTagUpdates } from '../lib/blobbi-streak';
-
-// ─── Content Helpers ──────────────────────────────────────────────────────────
-
-/**
- * Generate the content string for a Blobbi at a given stage.
- * Format: "{name} is a {stage} Blobbi."
- * 
- * Uses correct grammar: "an egg" vs "a baby/adult"
- */
-function generateBlobbiContent(name: string, stage: BlobbiStage): string {
-  const article = stage === 'egg' ? 'an' : 'a';
-  return `${name} is ${article} ${stage} Blobbi.`;
-}
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-/**
- * Result of ensuring canonical companion before action.
- * This is the same interface used by useBlobbiUseInventoryItem.
- */
-export interface CanonicalActionResult {
-  companion: BlobbiCompanion;
-  content: string;
-  allTags: string[][];
-  wasMigrated: boolean;
-  /** Latest profile tags after migration */
-  profileAllTags: string[][];
-  /** Latest profile storage after migration */
-  profileStorage: import('@/blobbi/core/lib/blobbi').StorageItem[];
-}
-
-/**
- * Parameters for stage transition hooks.
- */
-export interface UseBlobbiStageTransitionParams {
-  companion: BlobbiCompanion | null;
-  profile: BlobbonautProfile | null;
-  /** Called to ensure companion is canonical (from migration helper) */
-  ensureCanonicalBeforeAction: () => Promise<CanonicalActionResult | null>;
-  /** Update companion event in local cache */
-  updateCompanionEvent: (event: NostrEvent) => void;
-}
-
-/**
- * Result of a stage transition.
- */
-export interface StageTransitionResult {
-  /** Previous stage before transition */
-  previousStage: BlobbiStage;
-  /** New stage after transition */
-  newStage: BlobbiStage;
-  /** The Blobbi's name */
-  name: string;
-  /** Stats after decay was applied (before any transition bonuses) */
-  decayedStats: {
-    hunger: number;
-    happiness: number;
-    health: number;
-    hygiene: number;
-    energy: number;
-  };
-}
-
-// ─── Hatch Hook ───────────────────────────────────────────────────────────────
-
-/**
- * Hook to hatch an egg into a baby Blobbi.
- * 
- * Transition: egg -> baby
- * 
- * Requirements:
- * - Blobbi must be in egg stage
- * - Applies accumulated decay before transition
- * - Resets stats to healthy baby defaults (inherits health from egg)
- * - Sets last_decay_at to current timestamp
- */
-export function useBlobbiHatch({
-  companion,
-  profile,
-  ensureCanonicalBeforeAction,
-  updateCompanionEvent,
-}: UseBlobbiStageTransitionParams) {
-  const { user } = useCurrentUser();
-  const { mutateAsync: publishEvent } = useNostrPublish();
-
-  return useMutation({
-    mutationFn: async (): Promise<StageTransitionResult> => {
-      // ─── Validation ───
-      if (!user?.pubkey) {
-        throw new Error('You must be logged in to hatch');
-      }
-
-      if (!companion) {
-        throw new Error('No companion selected');
-      }
-
-      if (!profile) {
-        throw new Error('Profile not found');
-      }
-
-      if (companion.stage !== 'egg') {
-        throw new Error('Only eggs can be hatched');
-      }
-
-      // ─── Ensure Canonical Before Action ───
-      const canonical = await ensureCanonicalBeforeAction();
-      if (!canonical) {
-        throw new Error('Failed to prepare companion for hatching');
-      }
-
-      // ─── Apply Accumulated Decay First ───
-      // Per decay-system.md: Always apply accumulated decay from persisted state
-      // before any stage transition.
-      const now = Math.floor(Date.now() / 1000);
-      const decayResult = applyBlobbiDecay({
-        stage: canonical.companion.stage,
-        state: canonical.companion.state,
-        stats: canonical.companion.stats,
-        lastDecayAt: canonical.companion.lastDecayAt,
-        now,
-      });
-
-      // ─── Calculate Baby Stats ───
-      // All stats reset to 100 when hatching — the baby starts fresh
-      const babyStats = {
-        hunger: STAT_MAX,
-        happiness: STAT_MAX,
-        health: STAT_MAX,
-        hygiene: STAT_MAX,
-        energy: STAT_MAX,
-      };
-
-      // ─── Build Updated Tags ───
-      // CRITICAL: Start from canonical.allTags and only remove task/state-specific tags
-      // This preserves ALL identity attributes (personality, trait, favorite_food, etc.)
-      const nowStr = now.toString();
-      
-      // Build the updated tags using the central merge function
-      // Get streak updates (hatching counts as care activity!)
-      const streakUpdates = getStreakTagUpdates(canonical.companion) ?? {};
-      
-      const mergedTags = updateBlobbiTags(canonical.allTags, {
-        stage: 'baby',
-        state: 'active', // Newly hatched babies are awake
-        hunger: babyStats.hunger.toString(),
-        happiness: babyStats.happiness.toString(),
-        health: babyStats.health.toString(),
-        hygiene: babyStats.hygiene.toString(),
-        energy: babyStats.energy.toString(),
-        ...streakUpdates,
-        last_interaction: nowStr,
-        last_decay_at: nowStr,
-      });
-      
-      // ─── Validate and Repair Tags ───
-      // Use the tag integrity guard to ensure all persistent tags are preserved
-      // and task-related tags are properly cleaned up for stage transitions
-      const repairResult = validateAndRepairBlobbiTags(
-        mergedTags,
-        canonical.allTags,
-        { cleanupTaskTags: true }
-      );
-      
-      if (repairResult.errors.length > 0) {
-        console.error('[Hatch] Tag validation errors:', repairResult.errors);
-        throw new Error(`Tag validation failed: ${repairResult.errors.join(', ')}`);
-      }
-      
-      if (repairResult.repaired && import.meta.env.DEV) {
-        console.log('[Hatch] Tag repairs applied:', repairResult.repairs);
-      }
-      
-      const newTags = repairResult.tags;
-
-      // ─── Generate New Content for Baby Stage ───
-      // CRITICAL: Content must reflect the new stage
-      const newContent = generateBlobbiContent(canonical.companion.name, 'baby');
-
-      // ─── Publish Event ───
-      const event = await publishEvent({
-        kind: KIND_BLOBBI_STATE,
-        content: newContent,
-        tags: newTags,
-      });
-
-      updateCompanionEvent(event);
-
-      return {
-        previousStage: 'egg',
-        newStage: 'baby',
-        name: canonical.companion.name,
-        decayedStats: decayResult.stats,
-      };
-    },
-    onSuccess: ({ name }) => {
-      toast({
-        title: 'Your egg hatched!',
-        description: `${name} is now a baby Blobbi! Take good care of them.`,
-      });
-    },
-    onError: (error: Error) => {
-      toast({
-        title: 'Failed to hatch',
-        description: error.message,
-        variant: 'destructive',
-      });
-    },
-  });
-}
-
-// ─── Evolve Hook ──────────────────────────────────────────────────────────────
-
-/**
- * Hook to evolve a baby Blobbi into an adult.
- * 
- * Transition: baby -> adult
- * 
- * Requirements:
- * - Blobbi must be in baby stage
- * - Applies accumulated decay before transition
- * - Preserves all stats (decay already applied)
- * - Sets last_decay_at to current timestamp
- */
-export function useBlobbiEvolve({
-  companion,
-  profile,
-  ensureCanonicalBeforeAction,
-  updateCompanionEvent,
-}: UseBlobbiStageTransitionParams) {
-  const { user } = useCurrentUser();
-  const { mutateAsync: publishEvent } = useNostrPublish();
-
-  return useMutation({
-    mutationFn: async (): Promise<StageTransitionResult> => {
-      // ─── Validation ───
-      if (!user?.pubkey) {
-        throw new Error('You must be logged in to evolve');
-      }
-
-      if (!companion) {
-        throw new Error('No companion selected');
-      }
-
-      if (!profile) {
-        throw new Error('Profile not found');
-      }
-
-      if (companion.stage !== 'baby') {
-        if (companion.stage === 'egg') {
-          throw new Error('Eggs must hatch before they can evolve');
-        }
-        if (companion.stage === 'adult') {
-          throw new Error('This Blobbi is already fully evolved');
-        }
-        throw new Error('Only baby Blobbis can evolve');
-      }
-
-      // ─── Ensure Canonical Before Action ───
-      const canonical = await ensureCanonicalBeforeAction();
-      if (!canonical) {
-        throw new Error('Failed to prepare companion for evolution');
-      }
-
-      // ─── Apply Accumulated Decay First ───
-      // Per decay-system.md: Always apply accumulated decay from persisted state
-      // before any stage transition.
-      const now = Math.floor(Date.now() / 1000);
-      const decayResult = applyBlobbiDecay({
-        stage: canonical.companion.stage,
-        state: canonical.companion.state,
-        stats: canonical.companion.stats,
-        lastDecayAt: canonical.companion.lastDecayAt,
-        now,
-      });
-
-      // ─── Adult Stats ───
-      // Adult inherits all decayed stats from baby
-      // No stat reset - evolution preserves current condition
-      const adultStats = decayResult.stats;
-
-      // ─── Build Updated Tags ───
-      // CRITICAL: Start from canonical.allTags and only remove task/state-specific tags
-      // This preserves ALL identity attributes (personality, trait, favorite_food, etc.)
-      const nowStr = now.toString();
-      
-      // Get streak updates (evolving counts as care activity!)
-      const streakUpdates = getStreakTagUpdates(canonical.companion) ?? {};
-      
-      // Build the updated tags using the central merge function
-      const mergedTags = updateBlobbiTags(canonical.allTags, {
-        stage: 'adult',
-        state: 'active', // Evolution completes with active state
-        hunger: adultStats.hunger.toString(),
-        happiness: adultStats.happiness.toString(),
-        health: adultStats.health.toString(),
-        hygiene: adultStats.hygiene.toString(),
-        energy: adultStats.energy.toString(),
-        ...streakUpdates,
-        last_interaction: nowStr,
-        last_decay_at: nowStr,
-      });
-      
-      // ─── Validate and Repair Tags ───
-      // Use the tag integrity guard to ensure all persistent tags are preserved
-      // and task-related tags are properly cleaned up for stage transitions
-      const repairResult = validateAndRepairBlobbiTags(
-        mergedTags,
-        canonical.allTags,
-        { cleanupTaskTags: true }
-      );
-      
-      if (repairResult.errors.length > 0) {
-        console.error('[Evolve] Tag validation errors:', repairResult.errors);
-        throw new Error(`Tag validation failed: ${repairResult.errors.join(', ')}`);
-      }
-      
-      if (repairResult.repaired && import.meta.env.DEV) {
-        console.log('[Evolve] Tag repairs applied:', repairResult.repairs);
-      }
-      
-      const newTags = repairResult.tags;
-
-      // ─── Generate New Content for Adult Stage ───
-      // CRITICAL: Content must reflect the new stage
-      const newContent = generateBlobbiContent(canonical.companion.name, 'adult');
-
-      // ─── Publish Event ───
-      const event = await publishEvent({
-        kind: KIND_BLOBBI_STATE,
-        content: newContent,
-        tags: newTags,
-      });
-
-      updateCompanionEvent(event);
-
-      return {
-        previousStage: 'baby',
-        newStage: 'adult',
-        name: canonical.companion.name,
-        decayedStats: decayResult.stats,
-      };
-    },
-    onSuccess: ({ name }) => {
-      toast({
-        title: 'Evolution complete!',
-        description: `${name} has evolved into an adult Blobbi!`,
-      });
-    },
-    onError: (error: Error) => {
-      toast({
-        title: 'Failed to evolve',
-        description: error.message,
-        variant: 'destructive',
-      });
-    },
-  });
-}

src/blobbi/actions/hooks/useBlobbiUseInventoryItem.ts

@@ -1,315 +0,0 @@
-// src/blobbi/actions/hooks/useBlobbiUseInventoryItem.ts
-
-import { useMutation } from '@tanstack/react-query';
-
-import { useCurrentUser } from '@/hooks/useCurrentUser';
-import { useNostrPublish } from '@/hooks/useNostrPublish';
-import { toast } from '@/hooks/useToast';
-
-import type { BlobbiCompanion, BlobbonautProfile } from '@/blobbi/core/lib/blobbi';
-import {
-  KIND_BLOBBI_STATE,
-  updateBlobbiTags,
-} from '@/blobbi/core/lib/blobbi';
-import { applyBlobbiDecay } from '@/blobbi/core/lib/blobbi-decay';
-import { getShopItemById } from '@/blobbi/shop/lib/blobbi-shop-items';
-import {
-  applyItemEffects,
-  canUseAction,
-  getStageRestrictionMessage,
-  clampStat,
-  applyStat,
-  hasMedicineEffectForEgg,
-  hasHygieneEffectForEgg,
-  incrementInteractionTaskTags,
-  type InventoryAction,
-  ACTION_METADATA,
-} from '../lib/blobbi-action-utils';
-import { trackMultipleDailyMissionActions } from '../lib/daily-mission-tracker';
-import type { DailyMissionAction } from '../lib/daily-missions';
-import { getStreakTagUpdates } from '../lib/blobbi-streak';
-import { calculateInventoryActionXP, applyXPGain, formatXPGain } from '../lib/blobbi-xp';
-import { HATCH_REQUIRED_INTERACTIONS } from './useHatchTasks';
-import { EVOLVE_REQUIRED_INTERACTIONS } from './useEvolveTasks';
-
-/**
- * Request payload for using an item on a Blobbi companion
- */
-export interface UseItemRequest {
-  itemId: string;
-  action: InventoryAction;
-}
-
-/**
- * Result of using an item on a Blobbi companion
- */
-export interface UseItemResult {
-  itemName: string;
-  action: InventoryAction;
-  statsChanged: Record<string, number>;
-  xpGained: number;
-  newXP: number;
-}
-
-/**
- * Parameters for the useBlobbiUseInventoryItem hook
- */
-export interface UseBlobbiUseInventoryItemParams {
-  companion: BlobbiCompanion | null;
-  profile: BlobbonautProfile | null;
-  /** Called after ensuring companion is canonical (from migration helper) */
-  ensureCanonicalBeforeAction: () => Promise<{
-    companion: BlobbiCompanion;
-    content: string;
-    allTags: string[][];
-    wasMigrated: boolean;
-    /** Latest profile tags after migration */
-    profileAllTags: string[][];
-    /** Latest profile storage after migration */
-    profileStorage: import('@/blobbi/core/lib/blobbi').StorageItem[];
-  } | null>;
-  /** Update companion event in local cache */
-  updateCompanionEvent: (event: NostrEvent) => void;
-  /** Update profile event in local cache */
-  updateProfileEvent: (event: NostrEvent) => void;
-}
-
-// Import NostrEvent type
-import type { NostrEvent } from '@nostrify/nostrify';
-
-/**
- * Hook to use an item on a Blobbi companion.
- * 
- * Items are reusable abilities sourced from the shop catalog — no
- * inventory ownership or quantity is required.
- * 
- * This hook:
- * 1. Validates the companion and item compatibility
- * 2. Ensures canonical format before action
- * 3. Applies accumulated decay, then item effects to Blobbi stats
- * 4. Updates Blobbi state (kind 31124)
- */
-export function useBlobbiUseInventoryItem({
-  companion,
-  profile,
-  ensureCanonicalBeforeAction,
-  updateCompanionEvent,
-  updateProfileEvent: _updateProfileEvent,
-}: UseBlobbiUseInventoryItemParams) {
-  const { user } = useCurrentUser();
-  const { mutateAsync: publishEvent } = useNostrPublish();
-
-  return useMutation({
-    mutationFn: async ({ itemId, action }: UseItemRequest): Promise<UseItemResult> => {
-      // ─── Validation ───
-      if (!user?.pubkey) {
-        throw new Error('You must be logged in to use items');
-      }
-
-      if (!companion) {
-        throw new Error('No companion selected');
-      }
-
-      if (!profile) {
-        throw new Error('Profile not found');
-      }
-
-      // Check stage restrictions for this specific action
-      if (!canUseAction(companion, action)) {
-        const message = getStageRestrictionMessage(companion, action);
-        throw new Error(message ?? 'This companion cannot use this item');
-      }
-
-      // Validate item exists in shop catalog
-      const shopItem = getShopItemById(itemId);
-      if (!shopItem) {
-        throw new Error('Item not found in catalog');
-      }
-
-      // Validate item has effects
-      if (!shopItem.effect) {
-        throw new Error('This item has no effect');
-      }
-
-      // For eggs, validate that items have applicable effects
-      const isEgg = companion.stage === 'egg';
-      if (isEgg && action === 'medicine' && !hasMedicineEffectForEgg(shopItem.effect)) {
-        throw new Error('This medicine has no effect on eggs');
-      }
-      if (isEgg && action === 'clean' && !hasHygieneEffectForEgg(shopItem.effect)) {
-        throw new Error('This item has no cleaning effect on eggs');
-      }
-
-      // ─── Ensure Canonical Before Action ───
-      const canonical = await ensureCanonicalBeforeAction();
-      if (!canonical) {
-        throw new Error('Failed to prepare companion for action');
-      }
-
-      // ─── Apply Accumulated Decay First ───
-      // Per decay-system.md: Always apply accumulated decay from persisted state
-      // before any user interaction updates stats.
-      // CRITICAL: Use canonical.companion for decay calculations, not the stale outer companion
-      const now = Math.floor(Date.now() / 1000);
-      const decayResult = applyBlobbiDecay({
-        stage: canonical.companion.stage,
-        state: canonical.companion.state,
-        stats: canonical.companion.stats,
-        lastDecayAt: canonical.companion.lastDecayAt,
-        now,
-      });
-      
-      // Start with decayed stats as the base
-      const statsAfterDecay = decayResult.stats;
-      
-      // ─── Validate Play Energy Requirements ───
-      // For play actions, validate the Blobbi has enough energy AFTER decay
-      if (action === 'play') {
-        const energyCost = Math.abs(shopItem.effect.energy ?? 0);
-        const currentEnergy = statsAfterDecay.energy;
-        
-        if (energyCost > 0 && currentEnergy < energyCost) {
-          throw new Error(
-            `Your Blobbi needs at least ${energyCost} energy to play with this toy (current: ${currentEnergy})`
-          );
-        }
-        
-        // Also check if playing would have any effect at all
-        // If happiness is maxed AND we can't spend energy, playing is pointless
-        const happinessGain = shopItem.effect.happiness ?? 0;
-        const currentHappiness = statsAfterDecay.happiness;
-        const wouldGainHappiness = happinessGain > 0 && currentHappiness < 100;
-        const wouldSpendEnergy = energyCost > 0 && currentEnergy >= energyCost;
-        
-        if (!wouldGainHappiness && !wouldSpendEnergy) {
-          throw new Error(
-            'Playing would have no effect - your Blobbi is already at maximum happiness and has no energy to spend'
-          );
-        }
-      }
-      
-      // ─── Apply Item Effects (single use) ───
-      const isEggCompanion = canonical.companion.stage === 'egg';
-      const statsUpdate: Record<string, string> = {};
-      const statsChanged: Record<string, number> = {};
-
-      if (isEggCompanion && action === 'medicine') {
-        const healthDelta = shopItem.effect.health ?? 0;
-        const currentHealth = applyStat(statsAfterDecay.health ?? 0, healthDelta);
-        
-        statsUpdate.health = currentHealth.toString();
-        statsChanged.health = currentHealth - (statsAfterDecay.health ?? 0);
-        
-        statsUpdate.hygiene = (statsAfterDecay.hygiene ?? 0).toString();
-        statsUpdate.happiness = (statsAfterDecay.happiness ?? 0).toString();
-        statsUpdate.hunger = '100';
-        statsUpdate.energy = '100';
-      } else if (isEggCompanion && action === 'clean') {
-        const currentHygiene = applyStat(statsAfterDecay.hygiene ?? 0, shopItem.effect.hygiene ?? 0);
-        const currentHappiness = applyStat(statsAfterDecay.happiness ?? 0, shopItem.effect.happiness ?? 0);
-        
-        statsUpdate.hygiene = currentHygiene.toString();
-        statsChanged.hygiene = currentHygiene - (statsAfterDecay.hygiene ?? 0);
-        
-        statsUpdate.happiness = currentHappiness.toString();
-        const totalHappinessChange = currentHappiness - (statsAfterDecay.happiness ?? 0);
-        if (totalHappinessChange !== 0) {
-          statsChanged.happiness = totalHappinessChange;
-        }
-        
-        statsUpdate.health = (statsAfterDecay.health ?? 0).toString();
-        statsUpdate.hunger = '100';
-        statsUpdate.energy = '100';
-      } else {
-        // Normal stats application for baby/adult — apply once
-        const currentStats = applyItemEffects({ ...statsAfterDecay }, shopItem.effect);
-
-        statsUpdate.hunger = clampStat(currentStats.hunger).toString();
-        statsChanged.hunger = (currentStats.hunger ?? 0) - (statsAfterDecay.hunger ?? 0);
-        
-        statsUpdate.happiness = clampStat(currentStats.happiness).toString();
-        statsChanged.happiness = (currentStats.happiness ?? 0) - (statsAfterDecay.happiness ?? 0);
-        
-        statsUpdate.energy = clampStat(currentStats.energy).toString();
-        statsChanged.energy = (currentStats.energy ?? 0) - (statsAfterDecay.energy ?? 0);
-        
-        statsUpdate.hygiene = clampStat(currentStats.hygiene).toString();
-        statsChanged.hygiene = (currentStats.hygiene ?? 0) - (statsAfterDecay.hygiene ?? 0);
-        
-        statsUpdate.health = clampStat(currentStats.health).toString();
-        statsChanged.health = (currentStats.health ?? 0) - (statsAfterDecay.health ?? 0);
-      }
-
-      // ─── Update Blobbi State Event (kind 31124) ───
-      const nowStr = now.toString();
-      
-      // If incubating or evolving, increment the interaction counter for tasks
-      const companionState = canonical.companion.state;
-      let updatedTags = canonical.allTags;
-      if (companionState === 'incubating') {
-        updatedTags = incrementInteractionTaskTags(canonical.allTags, HATCH_REQUIRED_INTERACTIONS).updatedTags;
-      } else if (companionState === 'evolving') {
-        updatedTags = incrementInteractionTaskTags(canonical.allTags, EVOLVE_REQUIRED_INTERACTIONS).updatedTags;
-      }
-      
-      // Get streak updates (will only update if needed based on day)
-      const streakUpdates = getStreakTagUpdates(canonical.companion) ?? {};
-      
-      // ─── Apply XP Gain ───
-      const xpGained = calculateInventoryActionXP(action, 1);
-      const currentXP = canonical.companion.experience ?? 0;
-      const newXP = applyXPGain(currentXP, xpGained);
-      
-      const blobbiTags = updateBlobbiTags(updatedTags, {
-        ...statsUpdate,
-        ...streakUpdates,
-        experience: newXP.toString(),
-        last_interaction: nowStr,
-        last_decay_at: nowStr,
-      });
-
-      const blobbiEvent = await publishEvent({
-        kind: KIND_BLOBBI_STATE,
-        content: canonical.content,
-        tags: blobbiTags,
-      });
-
-      updateCompanionEvent(blobbiEvent);
-
-      // Items are free to use — no storage decrement needed.
-      // No query invalidation needed — the optimistic update above keeps the
-      // cache correct, and ensureCanonicalBeforeAction fetches fresh from relays
-      // before every mutation (read-modify-write pattern).
-
-      return {
-        itemName: shopItem.name,
-        action,
-        statsChanged,
-        xpGained,
-        newXP,
-      };
-    },
-    onSuccess: ({ itemName, action, xpGained }) => {
-      const actionMeta = ACTION_METADATA[action];
-      const xpText = formatXPGain(xpGained);
-      toast({
-        title: `${actionMeta.label} successful!`,
-        description: `Used ${itemName} on your Blobbi. ${xpText}`,
-      });
-
-      // Track daily mission progress
-      // 'interact' is always tracked, plus the specific action if it maps to a daily mission
-      const dailyActions: DailyMissionAction[] = ['interact'];
-      if (action === 'feed') dailyActions.push('feed');
-      if (action === 'clean') dailyActions.push('clean');
-      trackMultipleDailyMissionActions(dailyActions, user?.pubkey);
-    },
-    onError: (error: Error) => {
-      toast({
-        title: 'Failed to use item',
-        description: error.message,
-        variant: 'destructive',
-      });
-    },
-  });
-}

src/blobbi/actions/hooks/useClaimMissionReward.ts

@@ -1,121 +0,0 @@
-/**
- * useAwardDailyXp - Award XP for completed daily missions
- *
- * Completion is implicit (derived from progress vs target).
- * This hook calculates the total XP earned today and persists
- * the updated XP total to kind 11125 tags.
- *
- * Uses fetchFreshEvent to avoid stale-read overwrites when
- * multiple mutations race (e.g. item use XP + daily XP).
- */
-
-import { useMutation, useQueryClient } from '@tanstack/react-query';
-import { useNostr } from '@nostrify/react';
-
-import { useCurrentUser } from '@/hooks/useCurrentUser';
-import { useNostrPublish } from '@/hooks/useNostrPublish';
-import { toast } from '@/hooks/useToast';
-import { fetchFreshEvent } from '@/lib/fetchFreshEvent';
-
-import {
-  KIND_BLOBBONAUT_PROFILE,
-  updateBlobbonautTags,
-  parseBlobbonautEvent,
-} from '@/blobbi/core/lib/blobbi';
-import { buildXpTagUpdates } from '@/blobbi/core/lib/progression';
-import { serializeProfileContent } from '@/blobbi/core/lib/missions';
-import type { MissionsContent } from '@/blobbi/core/lib/missions';
-import { totalDailyXp } from '../lib/daily-missions';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-export interface AwardDailyXpRequest {
-  /** Current missions state to calculate XP from */
-  missions: MissionsContent;
-}
-
-export interface AwardDailyXpResult {
-  xpAwarded: number;
-  newTotalXp: number;
-}
-
-// ─── Hook ─────────────────────────────────────────────────────────────────────
-
-/**
- * Hook to award XP for completed daily missions.
- *
- * @param updateProfileEvent - Callback to update profile in query cache
- */
-export function useAwardDailyXp(
-  updateProfileEvent: (event: import('@nostrify/nostrify').NostrEvent) => void,
-) {
-  const { user } = useCurrentUser();
-  const { nostr } = useNostr();
-  const { mutateAsync: publishEvent } = useNostrPublish();
-  const queryClient = useQueryClient();
-
-  return useMutation({
-    mutationFn: async ({ missions }: AwardDailyXpRequest): Promise<AwardDailyXpResult> => {
-      if (!user?.pubkey) throw new Error('Must be logged in');
-
-      const xpToAward = totalDailyXp(missions);
-      if (xpToAward <= 0) return { xpAwarded: 0, newTotalXp: 0 };
-
-      // Fetch fresh profile from relays to avoid stale-read overwrites
-      const prev = await fetchFreshEvent(nostr, {
-        kinds: [KIND_BLOBBONAUT_PROFILE],
-        authors: [user.pubkey],
-      });
-
-      const freshProfile = prev ? parseBlobbonautEvent(prev) : undefined;
-      const currentXp = freshProfile?.xp ?? 0;
-      const newTotalXp = currentXp + xpToAward;
-
-      // Update XP and level tags on the fresh event's tags
-      const updatedTags = updateBlobbonautTags(
-        prev?.tags ?? [],
-        buildXpTagUpdates(newTotalXp),
-      );
-
-      // Persist missions state to content field
-      const content = serializeProfileContent(
-        prev?.content ?? '',
-        { missions },
-      );
-
-      const event = await publishEvent({
-        kind: KIND_BLOBBONAUT_PROFILE,
-        content,
-        tags: updatedTags,
-        prev: prev ?? undefined,
-      });
-
-      updateProfileEvent(event);
-
-      return { xpAwarded: xpToAward, newTotalXp };
-    },
-    onSuccess: ({ xpAwarded }) => {
-      if (user?.pubkey) {
-        queryClient.invalidateQueries({ queryKey: ['blobbonaut-profile', user.pubkey] });
-      }
-      if (xpAwarded > 0) {
-        toast({
-          title: 'XP Earned!',
-          description: `You earned ${xpAwarded} XP from daily missions.`,
-        });
-      }
-    },
-    onError: (error: Error) => {
-      toast({
-        title: 'Failed to Award XP',
-        description: error.message,
-        variant: 'destructive',
-      });
-    },
-  });
-}
-
-// Legacy export name for backward compatibility during migration
-export const useClaimMissionReward = useAwardDailyXp;
-export type ClaimMissionRequest = AwardDailyXpRequest;
-export type ClaimMissionResult = AwardDailyXpResult;

src/blobbi/actions/hooks/useDailyMissions.ts

@@ -1,209 +0,0 @@
-/**
- * useDailyMissions - Hook for reading daily mission state
- *
- * Provides reactive access to the current day's missions.
- * Progress tracking is done via the tracker module (non-React).
- * Completion is implicit (derived from count/events vs target).
- * XP is awarded automatically when missions complete.
- *
- * State lives in a pubkey-scoped in-memory Map. On mount or account
- * switch, hydrates from kind 11125 content JSON if the session store
- * is empty. Completed missions are persisted by `useAwardDailyXp`;
- * intermediate progress resets on page refresh.
- */
-
-import { useMemo, useEffect, useState, useCallback, useRef } from 'react';
-
-import { useCurrentUser } from '@/hooks/useCurrentUser';
-
-import type { MissionsContent } from '@/blobbi/core/lib/missions';
-import { isMissionComplete, missionProgress } from '@/blobbi/core/lib/missions';
-import { parseProfileContent } from '@/blobbi/core/lib/missions';
-
-import {
-  type BlobbiStage,
-  type DailyMissionAction,
-  getTodayDateString,
-  needsDailyReset,
-  createDailyMissionsContent,
-  areAllDailyComplete,
-  totalDailyXp,
-  getDefinition,
-  MAX_DAILY_REROLLS,
-  DAILY_BONUS_XP,
-} from '../lib/daily-missions';
-
-import {
-  readMissionsFromStorage,
-  writeMissionsToStorage,
-  hydrateFromPersisted,
-} from '../lib/daily-mission-tracker';
-
-// ─── Types ────────────────────────────────────────────────────────────────────
-
-export interface DailyMissionView {
-  /** Mission ID (matches pool definition) */
-  id: string;
-  /** Display title */
-  title: string;
-  /** Description */
-  description: string;
-  /** Action type */
-  action: DailyMissionAction;
-  /** Required count */
-  target: number;
-  /** Current progress */
-  progress: number;
-  /** Whether mission is complete */
-  complete: boolean;
-  /** XP reward */
-  xp: number;
-}
-
-export interface UseDailyMissionsOptions {
-  /** Available Blobbi stages the user has (filters eligible missions) */
-  availableStages?: BlobbiStage[];
-  /**
-   * Raw content string from the kind 11125 profile event.
-   * Pass `profile.content` here. The hook parses it to extract
-   * persisted missions and hydrates the session store on first load.
-   */
-  profileContent?: string;
-}
-
-export interface UseDailyMissionsResult {
-  /** Today's daily missions with computed progress */
-  missions: DailyMissionView[];
-  /** The raw missions content (for persistence/mutation hooks) */
-  raw: MissionsContent | undefined;
-  /** Whether all daily missions are complete */
-  allComplete: boolean;
-  /** Total XP earned today (completed missions + bonus) */
-  todayXp: number;
-  /** Whether the daily bonus is unlocked (all missions complete) */
-  bonusUnlocked: boolean;
-  /** Bonus XP amount */
-  bonusXp: number;
-  /** Whether user has no eligible missions */
-  noMissionsAvailable: boolean;
-  /** Rerolls remaining today */
-  rerollsRemaining: number;
-  /** Max rerolls per day */
-  maxRerolls: number;
-  /** Force refresh missions (testing) */
-  forceReset: () => void;
-}
-
-// ─── Hook ─────────────────────────────────────────────────────────────────────
-
-export function useDailyMissions(options: UseDailyMissionsOptions = {}): UseDailyMissionsResult {
-  const { availableStages, profileContent } = options;
-  const { user } = useCurrentUser();
-  const pubkey = user?.pubkey;
-
-  // Version counter to trigger re-reads from session store
-  const [version, setVersion] = useState(0);
-
-  // Track whether we've hydrated for this pubkey
-  const hydratedRef = useRef<string | null>(null);
-
-  // Hydrate session store from kind 11125 content on mount / account switch
-  useEffect(() => {
-    if (!pubkey || !profileContent) return;
-    if (hydratedRef.current === pubkey) return; // already hydrated this session
-
-    // Check if session store already has data for this pubkey
-    const existing = readMissionsFromStorage(pubkey);
-    if (existing) {
-      hydratedRef.current = pubkey;
-      return;
-    }
-
-    // Parse persisted missions from profile content
-    const parsed = parseProfileContent(profileContent);
-    if (parsed.missions && !needsDailyReset(parsed.missions)) {
-      hydrateFromPersisted(parsed.missions, pubkey);
-      hydratedRef.current = pubkey;
-      setVersion((v) => v + 1);
-    } else {
-      hydratedRef.current = pubkey;
-    }
-  }, [pubkey, profileContent]);
-
-  // Listen for tracker events
-  useEffect(() => {
-    const handler = () => setVersion((v) => v + 1);
-    window.addEventListener('daily-missions-updated', handler);
-    return () => window.removeEventListener('daily-missions-updated', handler);
-  }, []);
-
-  // Stable stages key for deps
-  const stagesKey = availableStages?.sort().join(',') ?? '';
-
-  // Read and ensure current state
-  const raw = useMemo((): MissionsContent | undefined => {
-    const stored = readMissionsFromStorage(pubkey);
-
-    if (!needsDailyReset(stored)) return stored;
-
-    // Reset for new day, preserve evolution missions
-    const fresh = createDailyMissionsContent(
-      getTodayDateString(),
-      stored?.evolution ?? [],
-      pubkey,
-      availableStages,
-    );
-    writeMissionsToStorage(fresh, pubkey);
-    return fresh;
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [version, pubkey, stagesKey]);
-
-  // Build view models
-  const missions: DailyMissionView[] = useMemo(() => {
-    if (!raw?.daily) return [];
-    return raw.daily.map((m) => {
-      const def = getDefinition(m.id);
-      return {
-        id: m.id,
-        title: def?.title ?? m.id,
-        description: def?.description ?? '',
-        action: def?.action ?? 'interact',
-        target: m.target,
-        progress: missionProgress(m),
-        complete: isMissionComplete(m),
-        xp: def?.xp ?? 0,
-      };
-    });
-  }, [raw]);
-
-  const allComplete = raw ? areAllDailyComplete(raw) : false;
-  const todayXp = raw ? totalDailyXp(raw) : 0;
-  const bonusUnlocked = allComplete;
-  const noMissionsAvailable = missions.length === 0;
-  const rerollsRemaining = raw?.rerolls ?? MAX_DAILY_REROLLS;
-
-  const forceReset = useCallback(() => {
-    const fresh = createDailyMissionsContent(
-      getTodayDateString(),
-      raw?.evolution ?? [],
-      pubkey,
-      availableStages,
-    );
-    writeMissionsToStorage(fresh, pubkey);
-    setVersion((v) => v + 1);
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  }, [pubkey, stagesKey, raw?.evolution]);
-
-  return {
-    missions,
-    raw,
-    allComplete,
-    todayXp,
-    bonusUnlocked,
-    bonusXp: DAILY_BONUS_XP,
-    noMissionsAvailable,
-    rerollsRemaining,
-    maxRerolls: MAX_DAILY_REROLLS,
-    forceReset,
-  };
-}