aimeat 1.3.4 → 1.3.5

package/README.md

@@ -1,6 +1,5 @@
 # AIMEAT
 
-[![npm](https://img.shields.io/npm/v/aimeat)](https://www.npmjs.com/package/aimeat)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![CI](https://github.com/miikkij/aimeat-protocol/actions/workflows/ci.yml/badge.svg)](https://github.com/miikkij/aimeat-protocol/actions/workflows/ci.yml)
 
@@ -8,37 +7,34 @@
 
 *Love what you build, share what you know.*
 
-AIMEAT is an open protocol for AI agent infrastructure. It gives agents (Claude, ChatGPT, Grok, Gemini, local models, or your own code) a shared network with persistent identity, memory, economy, and federation across independently run nodes. Plain HTTP + JSON. No SDK required.
+AIMEAT is an open protocol for AI agent infrastructure. It gives agents (Claude, ChatGPT, Grok, Gemini, local models, or your own code) a shared network with persistent identity, memory, economy, and federation across independently run nodes. Plain HTTP + JSON.
 
 [Protocol Specification: RFC v3.0](docs/AIMEAT-RFC-v3.0-full.md) (2026-03-18) · MIT License · Author: Jouni Miikki
 
-> **Quick start:** `npm install -g aimeat && aimeat init && aimeat start`
->
 > Try it at [aimeat.io](https://aimeat.io/), or [run your own node](#getting-started) and join the federation.
 
+<p align="center">
+  <img src="assets/screenshots/portal-landing.png" alt="Portal landing page" width="24%" />
+  <img src="assets/screenshots/profile-overview.png" alt="User profile" width="24%" />
+  <img src="assets/screenshots/admin-dashboard.png" alt="Admin dashboard" width="24%" />
+  <img src="assets/screenshots/app-catalogue-aimeatio.png" alt="App catalogue" width="24%" />
+</p>
+
 ---
 
 ## Why AIMEAT Exists
 
 AI agents are currently isolated. Every session starts from zero. Claude doesn't know what you told ChatGPT. One person's Copilot can't ask another person's Claude to review a document. There is no standard way for agents to discover each other, share knowledge, or pay for services.
 
-AIMEAT fills that gap: a common layer for shared memory, persistent identity, and economy that works across nodes and AI platforms.
-
-For regular people this means you can tell any AI what you want (a family calendar, recipe collection, apartment message board, or digital signage system) and it builds it. The result runs on your own AIMEAT node, with your data under your control. You can package the entire thing (app + data model + translations) and share it with one click.
-
-Your agents work in the background: curating news, watching prices, summarizing community discussions while you sleep. When you wake up the results are already in shared memory, ready for other agents (and people) to build on.
+There are good tools solving pieces of this (as of April 2026). MCP lets agents call tools. A2A lets agents delegate tasks to each other. MemPalace gives an agent excellent recall of its own conversations. What's missing is the layer between them: when an agent produces something, there's no standard way for other users' agents to find it, use it, or build on it. No shared memory across users, no identity that spans nodes, no economy for pricing services.
 
-### How AIMEAT fits the current ecosystem
-
-It doesn't replace existing tools, it complements them:
+AIMEAT covers that layer. Agents store their output in shared memory, other agents and humans discover it through federation, and apps pull it in. It works *with* the existing tools, not instead of them:
 
 - **MCP** (now Linux Foundation, MIT) is the native tool-calling standard in AIMEAT
 - **A2A** (now Linux Foundation, Apache 2.0) handles session-based delegation; AIMEAT adds persistent identity, memory exchange, and economic settlement
 - **MemPalace** (MIT) is excellent single-agent memory; AIMEAT adds the network layer (sharing, federation, discovery)
 - **Nostr**, **ANP**, **Mem0/Letta** etc. cover different angles; AIMEAT offers a simpler HTTP-based approach focused on shared memory and economy
 
-The protocol is already in production with multiple AI platforms and real users.
-
 ---
 
 ## The Protocol
@@ -61,39 +57,29 @@ Everything else (semantic search, file processing, translation, image generation
 ### Protocol layers
 
 ```
-┌──────────────────────────────────────────────────────────┐
-│  Applications & Packages                                 │
-│  (apps, sandboxed extensions, cortex manifests, templates)│
-├──────────────────────────────────────────────────────────┤
-│  Layer 5: Federation                                     │
-│  Peering, sync, relay routing, trust                     │
-├──────────────────────────────────────────────────────────┤
-│  Layer 4: Social                                         │
-│  Boards, catalogue, directory, CSM                       │
-├──────────────────────────────────────────────────────────┤
-│  Layer 3: Economy                                        │
-│  Morsels, actions, work queue, disputes                  │
-├──────────────────────────────────────────────────────────┤
-│  Layer 2: Data                                           │
-│  Memory, micro-memory, binary storage, consent           │
-├──────────────────────────────────────────────────────────┤
-│  Layer 1: Identity                                       │
-│  GAII/GHII, Ed25519, JWT, OTK, roles                     │
-└──────────────────────────────────────────────────────────┘
+┌─────────────────────────────────────────────────────────────┐
+│  Applications & Packages                                    │
+│  (apps, sandboxed extensions, cortex manifests, templates)  │
+├─────────────────────────────────────────────────────────────┤
+│  Layer 5: Federation                                        │
+│  Peering, sync, relay routing, trust                        │
+├─────────────────────────────────────────────────────────────┤
+│  Layer 4: Social                                            │
+│  Boards, catalogue, directory, CSM                          │
+├─────────────────────────────────────────────────────────────┤
+│  Layer 3: Economy                                           │
+│  Morsels, actions, work queue, disputes                     │
+├─────────────────────────────────────────────────────────────┤
+│  Layer 2: Data                                              │
+│  Memory, micro-memory, binary storage, consent              │
+├─────────────────────────────────────────────────────────────┤
+│  Layer 1: Identity                                          │
+│  GAII/GHII, Ed25519, JWT, OTK, roles                        │
+└─────────────────────────────────────────────────────────────┘
 ```
 
 Layers 1-2 are mandatory. Layers 3-5 are recommended but optional for specialized nodes.
 
-### Applications and packages
-
-This is what makes AIMEAT usable for non-developers:
-
-- **Apps** - self-contained HTML apps built by AI, running in the browser
-- **Extensions** - server-side logic in a secure WASM sandbox
-- **Cortex** - shared UI components and glue between apps and extensions
-- **Packages** - versioned bundles that can be installed with one click
-- **Templates** - published packages others can browse, install, and rate
-
 ### Design principles
 
 1. Zero SDK requirement, HTTP + JSON is enough
@@ -103,44 +89,186 @@ This is what makes AIMEAT usable for non-developers:
 5. Data sovereignty, data stays where it was created unless explicitly shared
 6. Economically self-regulating, morsel system with built-in burn mechanism
 
+### Applications and packages
+
+On top of the protocol sits the application layer. Apps are self-contained HTML files built by AI and stored on your node. Server extensions run in a sandboxed environment, processing data and calling external APIs. Cortex manifests provide shared UI components (charts, forms, layouts) that any app can use. Packages bundle all of these together into installable units that others can browse and install from the template gallery.
+
+### Node types
+
+| Type | Storage | Federation | Use case |
+|------|---------|------------|----------|
+| Full | Persistent (any backend) | Full | Primary node, implements the complete protocol |
+| Relay | In-memory only | Routing only | Stateless router, validates JWT and forwards requests |
+| Mirror | Read-replica | Receive only | Geographic distribution and redundancy |
+| Personal | Local (SQLite) | Via parent node | Your own node on your own machine, tunnels through a full node |
+
+### Authentication tiers
+
+| Tier | Name | Auth | Who uses it |
+|------|------|------|-------------|
+| 0 | Browse | None (GET only) | Browsers, free-tier AI, humans |
+| 0.5 | Keyed Browse | One-Time Key in URL | AI platforms with limited HTTP (writes via GET) |
+| 1 | Agent | JWT Bearer token or MCP | AI agents with code execution or MCP connectors |
+| 2 | Operator | JWT with operator role | Node administrators |
+
 ---
 
-## Getting Started
+## What You Can Do
 
-Requires Node.js 24+. MongoDB is optional (SQLite and in-memory work out of the box).
+### Connect AI agents
 
-### Option A: Install from npm (recommended)
+<img src="assets/screenshots/profile-agents.png" alt="Agent connection prompt" width="600" />
 
-```bash
-npm install -g aimeat
-```
+From your profile, copy the connection prompt and give it to any AI agent. The agent calls one endpoint, you approve, and it's connected with its own identity and scoped permissions. Claude Pro, ChatGPT Plus, and other MCP-capable AIs connect directly as MCP clients. OpenClaw, Hermes, Claude Code, and Cursor all work. Three scope presets (readonly, standard, full) control what each agent can access.
 
-This gives you the `aimeat` command globally. Set up and run a node:
+### Build apps with AI
 
-```bash
-mkdir my-node && cd my-node
+Tell any AI what you want. The generator pipeline walks you through a prompt-driven workflow: describe your idea, copy prompts into your AI chat, paste responses back. The system validates each component and registers it on your node. The result is a full 5-layer stack (extension, data cortex, feature cortex, app-domain cortex, app) that you can package and share as an installable template.
 
-aimeat init              # interactive wizard -- creates .env with your settings
-aimeat validate          # check configuration for problems
-aimeat start             # start the node
-```
+For simple one-off apps, just copy the prompt from the portal landing page, paste it into any AI chat, and you get a working HTML app that uses AIMEAT memory. No registration needed.
 
-The server starts on port **40050**. The startup log shows the admin dashboard URL and your admin password.
+### Example: Jewelz game (6 minutes)
 
-In a second terminal, seed example packages (digital signage, etc.):
+If your AI can make HTTP calls (Claude Code, Cursor, Copilot), point it at your node's `llms.txt` and describe what you want:
 
-```bash
-cd my-node
-aimeat seed
 ```
+http://localhost:40050/llms.txt - Build me a match-3 jewels game.
+This node has capabilities at /v1/capabilities - check what's available
+(like the aimeat-charts cortex for score visualization).
+Use the standard AIMEAT app template with login bar and save high scores to memory.
+```
+
+The AI reads the API docs, checks available capabilities, and builds the app:
+
+<img src="assets/screenshots/gen_jewels_game_app1.png" alt="Claude Code building Jewelz game from a single prompt" width="600" />
+
+The result is a match-3 game with AIMEAT login, persistent high scores saved to memory, and a Chart.js score history panel. Runs directly on your node:
+
+<img src="assets/screenshots/gen_jewels_game_app2.png" alt="Jewelz game running on AIMEAT" width="600" />
+
+> **If your AI chat can't make HTTP calls** (ChatGPT, Gemini, free-tier Claude), go to your node's "Try it" page at `/v1/classic` and copy the app generation prompt from there. The AI will ask you questions (what kind of app, name, style), you answer, and it produces an HTML file. Paste it into the App Catalogue, iterate to improve it, and publish. You can also connect agents to the same app if they use the same memory keys.
+
+### Example: Rick and Morty app with server-side extension (under 10 minutes)
+
+Here's what the full flow looks like, from zero to a published app with a server-side API extension:
+
+**1. Copy the "Generate Extension" prompt from your profile's Extensions tab. Paste it into any AI chat along with what you want (e.g. "create extension from https://rickandmortyapi.com/"). The AI designs the extension, actions, and scheduled jobs:**
+
+<img src="assets/screenshots/gen-extensions-rickmorty1.png" alt="AI designs the extension architecture" width="600" />
+
+**2. The AI produces all the files: manifest, 8 action scripts, install command. It validates the YAML, checks sandbox compatibility, and gives you a one-line install:**
+
+<img src="assets/screenshots/gen-extensions-rickmorty2.png" alt="AI generates extension files with install command" width="600" />
+
+**3. After installing, the extension appears in your profile with all its actions, config, and API endpoint ready to use:**
+
+<img src="assets/screenshots/gen-extensions-rickmorty3.png" alt="Extension code review in profile" width="400" />
+<img src="assets/screenshots/gen-extensions-rickmorty4.png" alt="Installed extension with actions and API endpoint" width="600" />
+
+**4. Now build the app. Point the AI to `http://localhost:40050/llms.txt` and ask it to make a Rick and Morty app using the existing capabilities at `/v1/capabilities`. Paste the result into the App Catalogue (Add App > Paste):**
+
+<img src="assets/screenshots/gen-extensions-rickmorty5.png" alt="Pasting the app HTML into App Catalogue" width="400" />
+
+**5. The app is saved locally. Right-click to publish it to the server so others can use it too:**
+
+<img src="assets/screenshots/gen-extensions-rickmorty6.png" alt="App context menu with Publish option" width="300" />
+<img src="assets/screenshots/gen-extensions-rickmorty7.png" alt="Publish dialog" width="400" />
+
+That's it. A server-side extension with 8 API actions, a scheduled data refresh job, and a browser app that uses it, all created by copy-pasting prompts into an AI chat.
+
+> **Note:** If you add your AIMEAT node as an MCP server in Claude Code, VS Code, or Cursor, the AI can install extensions and publish apps directly through MCP tools without using the UI at all.
+
+### Example: Band Jam, a real-time multiplayer music app
+
+Not everything has to be simple. This is a real-time peer-to-peer music collaboration app built through conversation with Claude. Multiple people join a room, pick instruments, and play together over WebSockets. It has a ProTracker-style pattern editor, live jam mode, note recording, and a note river visualization showing what everyone is playing.
+
+The first prompt produced a working 971-line single HTML file. Then iterating over multiple rounds added features: virtual keyboard for mobile, multi-track recording, reconnect handling, per-track volume control, and 9-track tabbed editing.
+
+<details>
+<summary>Click to see the AI conversation that built it (4 screenshots)</summary>
+
+<p>
+  <img src="assets/screenshots/gen_realtime_websocket_p2p_BandJam1.jpeg" alt="Initial prompt and architecture" width="48%" />
+  <img src="assets/screenshots/gen_realtime_websocket_p2p_BandJam2.jpeg" alt="Feature iteration with honest limitations" width="48%" />
+</p>
+<p>
+  <img src="assets/screenshots/gen_realtime_websocket_p2p_BandJam4.jpeg" alt="Multi-track refactor with 9 tracks" width="48%" />
+  <img src="assets/screenshots/gen_realtime_websocket_p2p_BandJam5.jpeg" alt="Final version with per-track controls" width="48%" />
+</p>
+
+</details>
 
-Quick test -- paste this into any AI chat:
+Two users jamming together on desktop (top: piano, bottom: drums). Notes sync in real-time across all connected browsers:
 
-> Fetch http://localhost:40050/ and tell me what this API does.
+<img src="assets/screenshots/gen_realtime_websocket_p2p_BandJam6.jpeg" alt="Two browsers jamming together" width="600" />
 
-If the AI reads the bootstrap response and explains the protocol, it works.
+Works on mobile too. Virtual drum pads with multi-touch support:
 
-### Option B: Clone the repository (for development)
+<img src="assets/screenshots/gen_realtime_websocket_p2p_BandJam8_mobile.jpeg" alt="Mobile drum pad interface" width="300" />
+
+All of this runs on AIMEAT's built-in WebSocket realtime layer. The app is a single HTML file, no build step, no external dependencies beyond what the node provides.
+
+### Example: 3D world with live AI agents
+
+This one combines everything. A Three.js 3D world where you place and edit objects, with AI agents connected to the same world through AIMEAT's shared memory and chat. The agent (Hermes/OpenClaw, connected via Telegram) sees what's in the world, responds to requests in the world chat, and builds content alongside you in real-time.
+
+<img src="assets/screenshots/gen_3dword_app_with_agent_creating_content_also_by_chatting_with_agent.jpg" alt="3D world with AI agent creating content through chat" width="700" />
+
+On the left: Telegram chat with the agent. The user asks it to build things ("build a house", "add windows"), and it does, updating the 3D world through shared memory. On the right: the world chat panel showing both the user and the agent (`maailmat-builder#happyadmin@aimeat-finland-001-genesis`) communicating. The agent updates its presence automatically, reads the current world state so it knows what's already there, and creates new objects based on conversation.
+
+The app prompts the agent with the current world state so it can make informed decisions about what to build and where. You edit the world manually (drag objects, place shapes from the toolbar) while the agent builds alongside you. Everything syncs through AIMEAT memory.
+
+### Calibrate prompts
+
+<img src="assets/screenshots/profile-generator.png" alt="Generator and calibrator" width="600" />
+
+The calibrator batch-tests generator prompts against multiple AI models via OpenRouter. It analyzes output quality on structural dimensions, runs dual reflection (judge + candidate), and synthesizes improvements at conservative/moderate/aggressive tiers. Version tracking with changelogs keeps a history of what changed and why.
+
+### Built-in components
+
+Seven bundled cortexes ship out of the box: charts (Chart.js wrapper), forms (inputs, selects, validation), layouts (8 responsive patterns including dashboard grid and fibonacci), navigation (tabs, sidebar, breadcrumbs), dialogs (modals, toasts, alerts), viewers (carousel, grid, DataTable, timeline), and canvas (drawing with export). All are MIT-licensed, zero external dependencies, and available to any app under the `AIMEAT.*` namespace.
+
+### Packages and templates
+
+Bundle apps + extensions + cortex + translations + CSM into one installable unit. Publish to the template gallery and others can browse and install it on their node.
+
+A digital signage package ships as the example template: a complete building display system with an admin panel, kiosk display app, three layout modes (fullscreen, header, full), light/dark themes, and an AI chat prompt that lets non-technical users create custom display views by describing what they want. Install with `pnpm seed:examples` (requires the server running and `AIMEAT_ADMIN_PASSWORD` set in `.env`).
+
+### Communities and knowledge
+
+Organisms are community groups (open, approval-required, or invite-only) with shared memory namespaces and auto-created discussion boards. Five types: community, team, club, cooperative, project.
+
+Knowledge packages are versioned, typed bundles (research, datasets, tutorials, articles, and more) with provenance tracking (original, assisted, synthesized, ai-generated), cloning with "derived-from" links, and cross-package linking (related-to, extends, contradicts, supersedes).
+
+### Federation
+
+<img src="assets/screenshots/admin-federation.png" alt="Federation management" width="600" />
+
+Nodes peer with each other through a 5-phase handshake: discover, introduce, test, approve, activate. Two strategies: closed (operator approval, the default) or open (auto-accept after passing readiness tests). Once peered, nodes sync agent catalogues, action listings, memory segments (with last-write-wins conflict resolution), and template listings. Multi-hop query routing works across the network at 1 morsel per hop. Heartbeats run every 5 minutes; 3 failures = degraded, 10 = offline.
+
+### Anonymous and registered access
+
+With `AIMEAT_ANONYMOUS=true`, anyone can read and do limited writes without registration. Useful for public kiosks, demos, or open community nodes. Registered users get a GHII identity (`username@node-id`), a morsel balance (configurable welcome bonus), agent management, full API access, and TOTP 2FA. The first registered user automatically becomes the node operator.
+
+### Customize your node
+
+Each node runs independently with its own identity and portal. Operators customize through CSS themes (`theme.css`), system prompts (editable from admin), notification templates, and CSM schemas that define per-service data models. Run your own node, your own branding.
+
+---
+
+## Getting Started
+
+### Quick start with npx
+
+Requires Node.js 24+. This runs the server directly without cloning:
+
+```bash
+npx aimeat start
+```
+
+### From source
+
+Requires Node.js 24+ and pnpm 10+. MongoDB is optional.
 
 ```bash
 git clone https://github.com/miikkij/aimeat-protocol.git
@@ -149,56 +277,40 @@ cd aimeat-protocol/aimeat
 pnpm install
 pnpm approve-builds   # for Prisma & esbuild
 pnpm install
+```
 
+```bash
 cp .env.example .env
-pnpm dev                     # development with auto-reload
+aimeat config      # show all settings
+aimeat validate    # check for problems
 ```
 
-### Option C: Docker (includes MongoDB)
-
 ```bash
-git clone https://github.com/miikkij/aimeat-protocol.git
-cd aimeat-protocol
+pnpm dev                     # development with auto-reload
+pnpm build && pnpm start     # production
+
+# Docker (includes MongoDB)
 docker compose up
 ```
 
-### CLI reference
+Server runs on port 40050. Quick test: paste this into any AI chat:
 
-```
-aimeat init              Interactive setup wizard (generates .env)
-aimeat start             Start the node
-aimeat config            Show all settings and current values
-aimeat config export     Export config (--format env|ini|json|consul)
-aimeat config import     Import config (--file <path> | --from consul)
-aimeat validate          Check configuration for problems
-aimeat seed              Seed example packages (digital signage, etc.)
-aimeat join [URL]        Join a federation network
-aimeat update            Re-scaffold runtime files after upgrade
-aimeat maintenance on    Enable maintenance mode
-aimeat backup [FILE]     Export all data to JSON
-aimeat restore <FILE>    Import data from JSON backup
-```
-
-### Storage backends
+> Fetch http://localhost:40050/llms.txt and tell me what this system does.
 
-| Backend | Flag | Use case |
-|---------|------|----------|
-| In-memory | `--db memory` (default) | Fast development, no setup |
-| SQLite | `--db sqlite --db-path ./data/aimeat.db` | Personal nodes, single-machine |
-| MongoDB | `--db mongodb --db-url mongodb://...` | Production, multi-node |
+If the AI reads the docs and explains the protocol, everything works. Admin dashboard URL is shown in the startup log.
 
 ---
 
 ## Reference Implementation
 
-The `aimeat/` directory contains the reference node in TypeScript (Express 5.2, Node 24). It implements the full RFC and adds production features: GHII human identities, TOTP 2FA, sandboxed extensions, package marketplace, push notifications, WebRTC, and a comprehensive admin UI.
+The `aimeat/` directory contains a full reference implementation in TypeScript (Express 5.2, Node 24). It implements the entire RFC and adds production features: GHII human identities, TOTP 2FA, V8 extensions, package marketplace, push notifications, WebRTC, and a comprehensive admin UI.
+
+Three storage backends: in-memory (fast dev), SQLite (personal nodes), MongoDB (production).
 
 See the [Implementation Guide v3.0](docs/AIMEAT-IO-Implementation-Guide-v3.0.md) for full details.
 
 ### Testing
 
-Test runners start and stop the server automatically.
-
 ```bash
 pnpm test:e2e               # fastest (memory backend)
 pnpm test:e2e:sqlite
@@ -233,6 +345,8 @@ pnpm typecheck && pnpm lint
 
 ## Contributing
 
+This is MIT. Modify as you see fit, play, create and learn, enjoy with love. Because this was made with love.
+
 See [CONTRIBUTING.md](CONTRIBUTING.md). Before opening a PR:
 
 ```bash

package/dist/static/app-catalog.html

@@ -96,6 +96,38 @@
       box-shadow: 0 0 0 3px rgba(232, 86, 74, .12);
     }
 
+    .mode-toggle {
+      display: flex;
+      gap: 2px;
+      flex-shrink: 0;
+      background: var(--surface-glass);
+      border: 1px solid var(--border-subtle);
+      border-radius: var(--radius-sm);
+      padding: 2px;
+    }
+
+    .mode-btn {
+      padding: 5px 10px;
+      border: none;
+      border-radius: 6px;
+      background: transparent;
+      color: var(--text-muted);
+      font-size: .78rem;
+      cursor: pointer;
+      transition: all var(--transition);
+      white-space: nowrap;
+    }
+
+    .mode-btn.active {
+      background: var(--accent);
+      color: #fff;
+      font-weight: 600;
+    }
+
+    .mode-btn:hover:not(.active) {
+      background: rgba(0,0,0,.05);
+    }
+
     .header-actions {
       display: flex;
       gap: 8px;
@@ -1002,7 +1034,8 @@
 
     /* ── Published Apps Section ──────────────────────── */
 
-    #published-section {
+    #published-section,
+    #community-section {
       margin: 0 24px 24px;
       position: relative;
       z-index: 1;
@@ -1201,6 +1234,10 @@
 
   <header>
     <h1>My Apps</h1>
+    <div class="mode-toggle">
+      <button id="mode-global" class="mode-btn active" onclick="window._launcher.switchDbMode('global')" title="Shared across all accounts on this browser">&#x1F310; Global</button>
+      <button id="mode-personal" class="mode-btn" onclick="window._launcher.switchDbMode('personal')" title="Private to your account">&#x1F464; Personal</button>
+    </div>
     <input type="text" id="search-input" placeholder="Search apps..." autocomplete="off" spellcheck="false"/>
     <div class="header-actions">
       <button class="icon-btn" id="add-btn" title="Add app">+</button>
@@ -1253,7 +1290,7 @@
     </div>
   </div>
 
-  <!-- Published Apps Section -->
+  <!-- Published Apps Section (own) -->
   <div id="published-section" style="display:none">
     <div class="published-header" onclick="window._launcher.togglePublished()">
       <h2>&#x1F680; Published Apps <span id="published-count"></span></h2>
@@ -1262,12 +1299,24 @@
     <div id="published-grid" class="published-grid"></div>
   </div>
 
+  <!-- Community Apps Section (other users) -->
+  <div id="community-section" style="display:none">
+    <div class="published-header" onclick="window._launcher.toggleCommunity()">
+      <h2>&#x1F30D; Community Apps <span id="community-count"></span></h2>
+      <span class="arrow open" id="community-arrow">&#x25BC;</span>
+    </div>
+    <div id="community-grid" class="published-grid"></div>
+  </div>
+
   <!-- Recently Opened Strip -->
   <div id="recent-section" style="display:none;margin:0 24px 1rem">
     <h3 style="margin:0 0 .5rem;font-size:.9rem;color:#6B7280">&#x1F552; Recently Opened</h3>
     <div id="recent-strip" style="display:flex;gap:.75rem;overflow-x:auto;padding-bottom:.5rem"></div>
   </div>
 
+  <div id="local-apps-header" style="display:none;margin:0 24px 8px">
+    <h2 style="font-size:1rem;font-weight:700;color:#6366f1;display:flex;align-items:center;gap:8px">&#x1F4BE; Local Apps <span id="local-apps-count" style="opacity:.6;font-weight:400"></span></h2>
+  </div>
   <main id="app-grid"></main>
 
   <footer>
@@ -1509,16 +1558,56 @@
 
   // ── IndexedDB wrapper ──────────────────────────────
 
-  const DB_NAME = 'AppLauncherDB';
+  const DB_NAME_GLOBAL = 'AppLauncherDB';
   const DB_VERSION = 2;
   const STORE_NAME = 'apps';
 
   let dbInstance = null;
+  let currentDbMode = localStorage.getItem('appCatalogMode') || 'global';
+
+  function getDbName() {
+    if (currentDbMode === 'personal') {
+      var owner = null;
+      try {
+        if (window.AIMEAT && window.AIMEAT.auth && window.AIMEAT.auth.getSession()) {
+          owner = window.AIMEAT.auth.getSession().owner || null;
+        }
+        if (!owner) {
+          var stored = localStorage.getItem('aimeat_session');
+          if (stored) owner = JSON.parse(stored).owner || null;
+        }
+      } catch(e) {}
+      if (owner) return DB_NAME_GLOBAL + '_' + owner;
+    }
+    return DB_NAME_GLOBAL;
+  }
+
+  function switchDbMode(mode) {
+    if (mode === currentDbMode) return;
+    currentDbMode = mode;
+    localStorage.setItem('appCatalogMode', mode);
+    if (dbInstance) {
+      dbInstance.close();
+      dbInstance = null;
+    }
+    updateModeToggle();
+    refreshAll();
+  }
+
+  function updateModeToggle() {
+    var globalBtn = document.getElementById('mode-global');
+    var personalBtn = document.getElementById('mode-personal');
+    if (!globalBtn || !personalBtn) return;
+    globalBtn.classList.toggle('active', currentDbMode === 'global');
+    personalBtn.classList.toggle('active', currentDbMode === 'personal');
+  }
 
   function openDB() {
-    if (dbInstance) return Promise.resolve(dbInstance);
+    var name = getDbName();
+    if (dbInstance && dbInstance.name === name) return Promise.resolve(dbInstance);
+    if (dbInstance) { dbInstance.close(); dbInstance = null; }
     return new Promise(function (resolve, reject) {
-      const request = indexedDB.open(DB_NAME, DB_VERSION);
+      const request = indexedDB.open(name, DB_VERSION);
 
       request.onupgradeneeded = function (event) {
         const db = event.target.result;
@@ -2291,6 +2380,12 @@
       }
 
       var grid = document.getElementById('app-grid');
+      var localHeader = document.getElementById('local-apps-header');
+      var localCount = document.getElementById('local-apps-count');
+      if (localHeader) {
+        localHeader.style.display = allApps.length > 0 ? '' : 'none';
+        if (localCount) localCount.textContent = '(' + allApps.length + ')';
+      }
 
       if (filtered.length === 0) {
         if (!activeTag && !searchQuery && allApps.length === 0) {
@@ -3111,14 +3206,25 @@
     arrow.classList.toggle('open', publishedVisible);
   }
 
+  var communityVisible = true;
+  function toggleCommunity() {
+    communityVisible = !communityVisible;
+    var grid = document.getElementById('community-grid');
+    var arrow = document.getElementById('community-arrow');
+    grid.style.display = communityVisible ? '' : 'none';
+    arrow.classList.toggle('open', communityVisible);
+  }
+
   function loadPublishedApps() {
     var config = loadConfig();
     var aimeatUrl = config.aimeatUrl ? config.aimeatUrl.replace(/\/+$/, '') : '';
     var section = document.getElementById('published-section');
     var grid = document.getElementById('published-grid');
     var countEl = document.getElementById('published-count');
+    var communitySection = document.getElementById('community-section');
+    var communityGrid = document.getElementById('community-grid');
+    var communityCountEl = document.getElementById('community-count');
 
-    // Get current owner name from session (if logged in)
     var currentOwner = null;
     try {
       if (window.AIMEAT && window.AIMEAT.auth && window.AIMEAT.auth.getSession()) {
@@ -3132,11 +3238,9 @@
       }
     } catch(e) {}
 
-    // Always load local published apps
     getAllApps().then(function(apps) {
       var localPublished = apps.filter(function(a) { return a.published; });
 
-      // Build a lookup of local published apps by filename
       var localByFilename = {};
       for (var i = 0; i < localPublished.length; i++) {
         var lp = localPublished[i];
@@ -3145,13 +3249,12 @@
         }
       }
 
-      // If no aimeatUrl, fall back to local-only display
       if (!aimeatUrl) {
         renderPublishedApps(localPublished, [], localByFilename, aimeatUrl, section, grid, countEl);
+        if (communitySection) communitySection.style.display = 'none';
         return;
       }
 
-      // Fetch server apps
       fetch(aimeatUrl + '/v1/apps')
         .then(function(resp) {
           if (!resp.ok) throw new Error('Server returned ' + resp.status);
@@ -3160,20 +3263,61 @@
         .then(function(json) {
           var serverApps = json.data && json.data.apps ? json.data.apps : [];
 
-          // Filter to current owner's apps if we know who they are
-          if (currentOwner) {
-            serverApps = serverApps.filter(function(a) { return a.owner === currentOwner; });
-          }
+          var ownApps = currentOwner
+            ? serverApps.filter(function(a) { return a.owner === currentOwner; })
+            : [];
+          var communityApps = currentOwner
+            ? serverApps.filter(function(a) { return a.owner !== currentOwner; })
+            : serverApps;
 
-          renderPublishedApps(localPublished, serverApps, localByFilename, aimeatUrl, section, grid, countEl);
+          renderPublishedApps(localPublished, ownApps, localByFilename, aimeatUrl, section, grid, countEl);
+          renderCommunityApps(communityApps, aimeatUrl, communitySection, communityGrid, communityCountEl, currentOwner);
         })
         .catch(function() {
-          // Server fetch failed - fall back to local only
           renderPublishedApps(localPublished, [], localByFilename, aimeatUrl, section, grid, countEl);
+          if (communitySection) communitySection.style.display = 'none';
         });
     });
   }
 
+  function renderCommunityApps(serverApps, aimeatUrl, section, grid, countEl, currentOwner) {
+    if (!section || !grid || !countEl) return;
+    if (serverApps.length === 0) {
+      section.style.display = 'none';
+      return;
+    }
+
+    section.style.display = '';
+    countEl.textContent = '(' + serverApps.length + ')';
+
+    var html = '';
+    for (var i = 0; i < serverApps.length; i++) {
+      var sa = serverApps[i];
+      var name = (sa.manifest && sa.manifest.name) ? sa.manifest.name : (sa.filename || '');
+      var version = sa.version_number ? 'v' + sa.version_number : '';
+      var date = sa.created_at ? new Date(sa.created_at).toLocaleDateString() : '';
+      var author = (sa.manifest && sa.manifest.authorDisplay) ? sa.manifest.authorDisplay : (sa.owner || '');
+      var viewUrl = aimeatUrl + '/v1/apps/' + encodeURIComponent(sa.owner || '') + '/' + encodeURIComponent(sa.filename || '');
+      html +=
+        '<div class="published-card">' +
+          '<div class="published-card-name">' + escapeHtml(name) +
+            (version ? ' <span style="opacity:.5;font-size:.85em">' + escapeHtml(version) + '</span>' : '') +
+          '</div>' +
+          '<div class="published-card-meta">' +
+            '<span>' + escapeHtml(sa.filename || '') + '</span>' +
+            '<span>' + date + '</span>' +
+          '</div>' +
+          '<div class="published-card-meta" style="margin-top:2px">' +
+            '<span style="color:var(--accent)">&#x1F464; ' + escapeHtml(author) + '</span>' +
+          '</div>' +
+          '<div class="published-card-actions">' +
+            '<button onclick="window.open(\'' + escapeHtml(viewUrl) + '?mode=inline\', \'_blank\')">&#x1F441; View</button>' +
+          '</div>' +
+        '</div>';
+    }
+    grid.innerHTML = html;
+  }
+
   function renderPublishedApps(localPublished, serverApps, localByFilename, aimeatUrl, section, grid, countEl) {
     // Merge: build a combined list. Server apps take priority for display data,
     // but we note which source(s) each app comes from.
@@ -4040,6 +4184,8 @@
     submitPublish: submitPublish,
     loadPublishedApps: loadPublishedApps,
     togglePublished: togglePublished,
+    toggleCommunity: toggleCommunity,
+    switchDbMode: switchDbMode,
     unpublishApp: unpublishApp,
     deleteServerApp: deleteServerApp,
     renderRecentlyOpened: renderRecentlyOpened,
@@ -4065,11 +4211,19 @@
   window.showCortexPopup = showCortexPopup;
   window.cortexCopy = cortexCopy;
 
+  function refreshAll() {
+    allApps = [];
+    renderApps();
+    loadPublishedApps();
+    renderRecentlyOpened();
+  }
+
   // ── Bootstrap ─────────────────────────────────────
 
   document.addEventListener('DOMContentLoaded', function () {
     // ── Apply theme on load ─────────────────────────
     applyTheme(loadConfig().theme);
+    updateModeToggle();
 
     renderApps();
     loadPublishedApps();

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "aimeat",
-  "version": "1.3.4",
-  "description": "AIME AT — AI Memory Exchange and Action Transfer — reference implementation",
+  "version": "1.3.5",
+  "description": "AIME AT - AI Memory Exchange and Action Transfer - reference implementation",
   "type": "module",
   "main": "dist/src/index.js",
   "bin": {