fix/rename (#20)

* chore: update AlphaHuman version to 0.49.3 and configure updater plugin in tauri.conf.json

- Bumped the AlphaHuman package version in Cargo.lock to 0.49.3.
- Added updater configuration in tauri.conf.json to enable automatic updates with specified endpoints.

* refactor: rename AlphaHuman to OpenHuman across the codebase

- Updated all instances of "AlphaHuman" to "OpenHuman" in comments, tooltips, and constants to reflect the new branding.
- Adjusted relevant documentation and prompts to ensure consistency with the new name.

* refactor: update documentation and configurations to reflect OpenHuman branding

- Replaced all instances of "AlphaHuman" with "OpenHuman" in documentation, comments, and configuration files to ensure consistency with the new branding.
- Updated deep link URLs and related authentication flows to use the new "openhuman://" scheme.
- Adjusted paths and references in the skills system and other related files to align with the new project name.te

* refactor: standardize OpenHuman references and update configurations

- Replaced all instances of "AlphaHuman" with "OpenHuman" across documentation, comments, and configuration files to maintain branding consistency.
- Updated URLs and paths to reflect the new "openhuman://" scheme.
- Adjusted environment variable names and related settings to align with the new project identity.
- Enhanced documentation for clarity and accuracy regarding the OpenHuman framework.r

* chore: update subproject commit reference in skills directory

* refactor: update backend URL to reflect new service domain

- Changed default backend URL from "https://api.openhuman.xyz" to "https://api.tinyhumans.ai" in both JavaScript and Rust configuration files.
- Ensured consistency across the codebase regarding the new backend service endpoint.

* feat: introduce identity and migration modules for OpenHuman

- Added a new identity module to support AIEOS v1.1 JSON format, including structures for identity, psychology, linguistics, motivations, capabilities, physicality, history, and interests.
- Implemented a migration module to facilitate data migration from OpenClaw memory, including SQLite and Markdown sources, with detailed reporting on migration statistics and warnings.
- Established utility functions for handling multimodal content and image processing within the OpenHuman framework.
- Enhanced the agent system with new dispatcher and classifier functionalities to improve tool management and message classification.

* chore: remove Android project files and configurations

- Deleted various Android project files including .editorconfig, .gitignore, build.gradle.kts, gradle.properties, and others to clean up the project structure.
- Removed all related resources, layouts, and source files from the Android app directory to streamline the codebase.
- This cleanup is part of a larger effort to refactor and simplify the project structure.

* refactor: update login flow and remove Telegram integration

- Removed the TelegramLoginButton component and its references from the OAuthLoginSection, streamlining the login options.
- Updated the AppRoutes to remove the login route, reflecting changes in the authentication flow.
- Enhanced the RotatingTetrahedronCanvas component with improved geometry and lighting effects for better visual presentation.
- Adjusted the TypewriterGreeting component's styling for consistency.
- Cleaned up the Welcome page to integrate the OAuthLoginSection directly, improving user experience.

* chore: update subproject commit reference in skills directory

* chore: update test configurations and improve test assertions

- Modified test scripts in package.json to use a specific Vitest configuration file for consistency.
- Updated assertions in loader tests to ensure loading durations are non-negative.
- Enhanced tool loading tests to clarify expected behavior regarding localStorage and cache management.
- Adjusted agent tool registry tests to improve error handling and ensure accurate statistics.
- Refined device detection tests to reflect updated fallback URLs.

* fix: enhance parameter formatting and remove unused components

- Updated the `formatParameters` function to handle cases where schema properties are empty, returning a more informative response.
- Deleted the `DownloadScreen` component and associated device detection utilities to streamline the codebase and remove unused functionality.
- Adjusted tests to reflect changes in the tool loading and agent tool registry, ensuring accuracy in assertions.

* chore: simplify Vitest configuration by removing unused include patterns

- Updated the Vitest configuration to remove unnecessary test file patterns, streamlining the test setup for better clarity and maintainability.

* refactor: update paths and comments for AI configuration and file watching

- Modified Vite configuration to ignore only the `src-tauri` directory.
- Updated logging messages to reflect the correct path for writing AI configuration files.
- Adjusted fetch calls in the file watcher to use the new path for `TOOLS.md`.
- Revised comments and logic in Rust code to clarify the handling of AI configuration file paths, including legacy fallback options.

* chore: remove unused updater secrets from GitHub Actions workflow

- Deleted UPDATER_GIST_URL and UPDATER_GIST_ID environment variables from the package-and-publish workflow, streamlining the configuration.

* chore: comment out Vitest thresholds for clarity

- Commented out the thresholds section in the Vitest configuration to improve clarity and maintainability, as it is currently not in use.

* ran formatter

* chore: update updater public key in tauri configuration

- Replaced the existing public key in the updater plugin configuration with a new value to ensure proper functionality and security.

* chore: update ESLint configuration and refactor components

- Added `localStorage` and `sessionStorage` as readonly globals in ESLint configuration for better linting support.
- Removed unused imports from `SkillsPanel.tsx` to clean up the code.
- Changed the type of `watcherInterval` in `file-watcher.ts` for improved type safety.
- Refactored toast management logic in `Intelligence.tsx` to enhance clarity and maintainability.
- Simplified import statements in `IntelligenceProvider.tsx` for consistency.
- Streamlined object property shorthand in `agentToolRegistry.ts` for cleaner code.

* refactor: improve error handling and type safety in Intelligence component

- Enhanced toast notification logic to defer state updates, preventing potential issues with setState in effects.
- Updated the source filter dispatch to use a more specific type for improved type safety.

* refactor: enhance type safety across various components and services

- Updated type definitions from `any` to `unknown` in multiple files to improve type safety and prevent potential runtime errors.
- Refactored state management in `TauriCommandsPanel` to use more specific types.
- Adjusted context and parameters in several interfaces to ensure consistent typing.
- Added ESLint directive to `polyfills.ts` for intentional global assignments.
- Streamlined type handling in utility functions and API responses for better clarity and maintainability.

* refactor: streamline import statements and improve code clarity

- Consolidated import statements in `agentToolRegistry.ts` and `intelligenceSlice.ts` for better readability.
- Simplified the `createTestStore` function in `test-utils.tsx` to enhance code conciseness.
- Cleaned up the `isExecutionStepProgressEvent` function in `intelligence-chat-api.ts` for improved clarity and maintainability.

.claude/mcp.json

@@ -1 +1 @@
-{ "mcpServers": { "alphaHuman": { "type": "http", "url": "https://alphahuman.readme.io/mcp" } } }
+{ "mcpServers": { "alphahuman": { "type": "http", "url": "https://openhuman.readme.io/mcp" } } }

.claude/rules/01-project-overview.md

@@ -58,7 +58,7 @@ This project is a **crypto-focused communication platform** built with Tauri v2,
 ## Project Structure
 
 ```
-frontend-runner-alphahuman/
+frontend-runner-openhuman/
 ├── .claude/                # Claude AI configuration
 │   ├── rules/              # Modular documentation
 │   └── agents/             # Subagent configurations
@@ -86,7 +86,7 @@ frontend-runner-alphahuman/
 
 ## Key Configuration Files
 
-- `tauri.conf.json` - Tauri configuration (app identifier: com.alphahuman.app)
+- `tauri.conf.json` - Tauri configuration (app identifier: com.openhuman.app)
 - `Cargo.toml` - Rust dependencies and workspace configuration
 - `package.json` - Node.js dependencies and scripts
 - `vite.config.ts` - Vite build configuration with Node.js polyfills

.claude/rules/02-development-commands.md

@@ -116,7 +116,7 @@ adb kill-server                  # Stop ADB server
 adb start-server                 # Restart ADB server
 
 # Force stop app on device:
-adb shell am force-stop com.alphahuman.app
+adb shell am force-stop com.openhuman.app
 
 # Kill Gradle daemon if stuck:
 # macOS/Linux:

.claude/rules/13-backend-auth-implementation.md

@@ -24,7 +24,7 @@ Web Browser                    Backend Server                 Desktop App (Tauri
     │<─────────────────────────────│                              │
     │                              │                              │
     │  5. Redirect to              │                              │
-    │     alphahuman://auth?token= │                              │
+    │     openhuman://auth?token= │                              │
     │─────────────────────────────────────────────────────────────>│
     │                              │                              │
     │                              │  6. Rust invoke               │
@@ -58,7 +58,7 @@ Initiates Telegram OAuth. The frontend opens this URL in the system browser.
 2. On callback, validate Telegram user data
 3. Create or find user in database
 4. Generate a short-lived `loginToken` (single-use, 5-minute TTL)
-5. Redirect to `alphahuman://auth?token=<loginToken>`
+5. Redirect to `openhuman://auth?token=<loginToken>`
 
 ### 2. `POST /api/auth/web-complete`
 
@@ -181,7 +181,7 @@ Called by the Tauri Rust command `exchange_token` (NOT browser fetch). Exchanges
 3. **HTTPS only** in production — tokens travel as URL parameters and POST bodies
 4. **Rate limiting** — on `/api/auth/web-complete` and `/auth/desktop-exchange`
 5. **Token entropy** — minimum 256 bits of randomness
-6. **Deep link validation** — the desktop app only processes `alphahuman://auth` paths; ignore unknown paths
+6. **Deep link validation** — the desktop app only processes `openhuman://auth` paths; ignore unknown paths
 7. **Telegram data verification** — validate the `hash` field using your bot token per Telegram docs
 
 ## Implementation Details
@@ -226,14 +226,14 @@ Set `VITE_BACKEND_URL` environment variable for different environments.
 
 ## Frontend Integration Points
 
-| File                                   | Role                                                                                  |
-| -------------------------------------- | ------------------------------------------------------------------------------------- |
-| `src/main.tsx`                         | Lazy-imports and starts the deep link listener                                        |
-| `src/utils/desktopDeepLinkListener.ts` | Parses deep link -> invokes Rust `exchange_token` -> stores session -> navigates      |
-| `src/utils/deeplink.ts`                | Web-side: calls `/api/auth/web-complete` and builds `alphahuman://auth?token=...` URL |
-| `src/utils/config.ts`                  | Backend URL configuration                                                             |
-| `src/pages/Login.tsx`                  | Opens `GET /auth/telegram?platform=desktop` in browser                                |
-| `src-tauri/src/lib.rs`                 | Rust `exchange_token` command using `reqwest` (CORS-free)                             |
+| File                                   | Role                                                                                 |
+| -------------------------------------- | ------------------------------------------------------------------------------------ |
+| `src/main.tsx`                         | Lazy-imports and starts the deep link listener                                       |
+| `src/utils/desktopDeepLinkListener.ts` | Parses deep link -> invokes Rust `exchange_token` -> stores session -> navigates     |
+| `src/utils/deeplink.ts`                | Web-side: calls `/api/auth/web-complete` and builds `openhuman://auth?token=...` URL |
+| `src/utils/config.ts`                  | Backend URL configuration                                                            |
+| `src/pages/Login.tsx`                  | Opens `GET /auth/telegram?platform=desktop` in browser                               |
+| `src-tauri/src/lib.rs`                 | Rust `exchange_token` command using `reqwest` (CORS-free)                            |
 
 ## Phone OTP Flow (Future)
 

.claude/rules/14-deep-link-platform-guide.md

@@ -2,14 +2,14 @@
 
 ## Overview
 
-The `alphahuman://` custom URL scheme is used to hand off authentication from a web browser to the Tauri desktop app. This document covers platform-specific behavior, gotchas, and build requirements discovered during development.
+The `openhuman://` custom URL scheme is used to hand off authentication from a web browser to the Tauri desktop app. This document covers platform-specific behavior, gotchas, and build requirements discovered during development.
 
 ## Scheme Registration
 
 Configured in `src-tauri/tauri.conf.json`:
 
 ```json
-{ "plugins": { "deep-link": { "desktop": { "schemes": ["alphahuman"] } } } }
+{ "plugins": { "deep-link": { "desktop": { "schemes": ["openhuman"] } } } }
 ```
 
 ## macOS
@@ -50,7 +50,7 @@ cp -R src-tauri/target/debug/bundle/macos/tauri-app.app /Applications/
 open /Applications/tauri-app.app
 
 # Test deep link
-open "alphahuman://auth?token=YOUR_TOKEN"
+open "openhuman://auth?token=YOUR_TOKEN"
 ```
 
 ### Cargo Caching Gotcha
@@ -68,9 +68,9 @@ open "alphahuman://auth?token=YOUR_TOKEN"
 - The macOS WebView (WKWebView) caches aggressively
 - Clear caches when debugging stale content:
   ```bash
-  rm -rf ~/Library/WebKit/com.alphahuman.app
-  rm -rf ~/Library/Caches/com.alphahuman.app
-  rm -rf ~/Library/Application\ Support/com.alphahuman.app
+  rm -rf ~/Library/WebKit/com.openhuman.app
+  rm -rf ~/Library/Caches/com.openhuman.app
+  rm -rf ~/Library/Application\ Support/com.openhuman.app
   ```
 
 ### Debug Builds: Secondary Instance Behavior

.claude/rules/16-macos-background-execution.md

@@ -213,8 +213,8 @@ npm run tauri build -- --debug --bundles app
 Clear WebKit cache if needed:
 
 ```bash
-rm -rf ~/Library/WebKit/com.alphahuman.app
-rm -rf ~/Library/Caches/com.alphahuman.app
+rm -rf ~/Library/WebKit/com.openhuman.app
+rm -rf ~/Library/Caches/com.openhuman.app
 ```
 
 ## Configuration Options

.claude/rules/17-skills-memory-inference-flow.md

@@ -31,10 +31,10 @@ Token present
 
 Two Tauri event listeners run continuously:
 
-| Event | What it does |
-|---|---|
-| `skill-state-changed` | Dispatches `setSkillState` into Redux `skillsSlice.skillStates[skillId]` |
-| `runtime:skill-status-changed` | Updates `skillsSlice.skills[skillId].status`; surfaces errors |
+| Event                          | What it does                                                             |
+| ------------------------------ | ------------------------------------------------------------------------ |
+| `skill-state-changed`          | Dispatches `setSkillState` into Redux `skillsSlice.skillStates[skillId]` |
+| `runtime:skill-status-changed` | Updates `skillsSlice.skills[skillId].status`; surfaces errors            |
 
 ---
 
@@ -48,7 +48,8 @@ It is constructed with the user's JWT (`authSlice.token`) and stored as `Arc<Mem
 in `MemoryState` (a `Mutex<Option<MemoryClientRef>>`).
 
 Base URL resolution (in priority order):
-1. `ALPHAHUMAN_BASE_URL` env var
+
+1. `OPENHUMAN_BASE_URL` env var
 2. `TINYHUMANS_BASE_URL` env var
 3. SDK default
 
@@ -109,12 +110,12 @@ Examples: `skill:gmail:user@example.com`, `skill:notion:default`.
 
 **File**: `src-tauri/src/memory/mod.rs`
 
-| Method | SDK call | When used |
-|---|---|---|
-| `store_skill_sync(...)` | `insert_memory` | OAuth complete, periodic sync |
-| `query_skill_context(...)` | `query_memory` | RAG query — fetch relevant chunks for a user question |
-| `recall_skill_context(...)` | `recall_memory` | Recall synthesised summary from Master node |
-| `clear_skill_memory(...)` | `delete_memory` | OAuth revoke / disconnect |
+| Method                      | SDK call        | When used                                             |
+| --------------------------- | --------------- | ----------------------------------------------------- |
+| `store_skill_sync(...)`     | `insert_memory` | OAuth complete, periodic sync                         |
+| `query_skill_context(...)`  | `query_memory`  | RAG query — fetch relevant chunks for a user question |
+| `recall_skill_context(...)` | `recall_memory` | Recall synthesised summary from Master node           |
+| `clear_skill_memory(...)`   | `delete_memory` | OAuth revoke / disconnect                             |
 
 ---
 
@@ -141,16 +142,17 @@ chatSend({ threadId, message, model, authToken, backendUrl, messages, notionCont
 
 Completion events flow back over Tauri events:
 
-| Event | Frontend handler |
-|---|---|
-| `chat:tool_call` | shows active tool indicator |
-| `chat:tool_result` | clears tool indicator |
-| `chat:done` | `dispatch(addInferenceResponse(...))` |
-| `chat:error` | shows error, clears loading state |
+| Event              | Frontend handler                      |
+| ------------------ | ------------------------------------- |
+| `chat:tool_call`   | shows active tool indicator           |
+| `chat:tool_result` | clears tool indicator                 |
+| `chat:done`        | `dispatch(addInferenceResponse(...))` |
+| `chat:error`       | shows error, clears loading state     |
 
 ### 5b. Web/Fallback Path
 
 Used when not running in Tauri (browser). Runs the agentic loop entirely in TypeScript:
+
 - Calls `inferenceApi.createChatCompletion(request)` directly
 - Executes tools via `skillManager.callTool(skillId, toolName, args)`
 - Both paths share the same 5-round `MAX_TOOL_ROUNDS` limit and `{skillId}__{toolName}` naming convention
@@ -215,6 +217,7 @@ Step 6: Agentic loop (max 5 rounds)
 **File**: `src-tauri/src/runtime/qjs_engine.rs` — `call_tool(skill_id, tool_name, args)`
 
 The Rust runtime routes `call_tool` into the running QuickJS/V8 skill instance:
+
 - Serialises `args` as JSON
 - Calls the JS tool handler registered by the skill
 - Returns `ToolCallResult { content: Vec<ToolContent>, is_error: bool }`
@@ -262,14 +265,14 @@ Separately (async, fire-and-forget):
 
 ## Key Files Reference
 
-| File | Role |
-|---|---|
-| `src/providers/SkillProvider.tsx` | Discovery, lifecycle, Redux state sync |
-| `src/pages/Conversations.tsx` | Message send, both code paths, Notion context |
-| `src/services/chatService.ts` | `chatSend()`, `chatCancel()`, `useRustChat()` |
-| `src-tauri/src/commands/chat.rs` | Rust agentic loop, context assembly, tool dispatch |
-| `src-tauri/src/commands/memory.rs` | `recall_memory` Tauri command |
-| `src-tauri/src/memory/mod.rs` | `MemoryClient` wrapping tinyhumansai SDK |
-| `src-tauri/src/runtime/qjs_skill_instance.rs` | Skill sync → memory write triggers |
-| `src-tauri/src/runtime/qjs_engine.rs` | `discover_skills()`, `call_tool()`, `all_tools()` |
-| `skills/skills/*/manifest.json` | Skill metadata (git submodule) |
+| File                                          | Role                                               |
+| --------------------------------------------- | -------------------------------------------------- |
+| `src/providers/SkillProvider.tsx`             | Discovery, lifecycle, Redux state sync             |
+| `src/pages/Conversations.tsx`                 | Message send, both code paths, Notion context      |
+| `src/services/chatService.ts`                 | `chatSend()`, `chatCancel()`, `useRustChat()`      |
+| `src-tauri/src/commands/chat.rs`              | Rust agentic loop, context assembly, tool dispatch |
+| `src-tauri/src/commands/memory.rs`            | `recall_memory` Tauri command                      |
+| `src-tauri/src/memory/mod.rs`                 | `MemoryClient` wrapping tinyhumansai SDK           |
+| `src-tauri/src/runtime/qjs_skill_instance.rs` | Skill sync → memory write triggers                 |
+| `src-tauri/src/runtime/qjs_engine.rs`         | `discover_skills()`, `call_tool()`, `all_tools()`  |
+| `skills/skills/*/manifest.json`               | Skill metadata (git submodule)                     |

.claude/skills-system-troubleshooting.md

@@ -10,7 +10,7 @@ The Skills System is a Python-based plugin architecture that allows AI agents to
 
 - Skills modal shows "Setup Failed" with "Skill process exited with code: 1"
 - Console shows `ModuleNotFoundError: No module named 'pydantic'`
-- Error paths like `/Users/cyrus/alphahuman/skills/skills/telegram/`
+- Error paths like `/Users/cyrus/openhuman/skills/skills/telegram/`
 - Python import failures and subprocess stderr messages
 
 ### Root Cause Analysis
@@ -51,7 +51,7 @@ git submodule init
 git submodule update
 ```
 
-This downloads the skills repository from `https://github.com/alphahumanxyz/skills`.
+This downloads the skills repository from `https://github.com/openhumanxyz/skills`.
 
 #### 2. Create Python Virtual Environment
 
@@ -87,7 +87,7 @@ This installs:
 #### Development vs Production Paths
 
 - **Development**: Skills in git submodule at `./skills/skills/`
-- **Production**: Skills in `~/.alphahuman/skills/`
+- **Production**: Skills in `~/.openhuman/skills/`
 - **Configuration**: `src/lib/skills/paths.ts` handles path resolution
 
 #### Skill Execution Process

.github/workflows/build.yml

@@ -27,7 +27,7 @@ jobs:
         uses: actions/setup-node@v4
         with:
           node-version: 24.x
-          cache: "yarn"
+          cache: 'yarn'
 
       - name: Install Rust stable
         uses: dtolnay/rust-toolchain@stable

.github/workflows/package-and-publish.yml

@@ -17,10 +17,8 @@ on:
 env:
   IS_PR: ${{ github.event_name == 'pull_request' }}
   SHOULD_PUBLISH: ${{ github.event_name != 'pull_request' && github.ref == 'refs/heads/main' }}
-  PUBLISH_REPO: alphahumanxyz/alphahuman
+  PUBLISH_REPO: openhumanxyz/openhuman
   XGH_TOKEN: ${{ secrets.XGH_TOKEN }}
-  UPDATER_GIST_URL: ${{ secrets.UPDATER_GIST_URL }}
-  UPDATER_GIST_ID: ${{ secrets.UPDATER_GIST_ID }}
   GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 
 jobs:
@@ -48,7 +46,7 @@ jobs:
         run: |
           PACKAGE_VERSION=$(node -p "require('./package.json').version")
           TAG_NAME="v${PACKAGE_VERSION}"
-          RELEASE_NAME="AlphaHuman v${PACKAGE_VERSION}"
+          RELEASE_NAME="OpenHuman v${PACKAGE_VERSION}"
           echo "package-version=$PACKAGE_VERSION" >> $GITHUB_OUTPUT
           echo "tag-name=$TAG_NAME" >> $GITHUB_OUTPUT
           echo "release-name=$RELEASE_NAME" >> $GITHUB_OUTPUT
@@ -162,15 +160,15 @@ jobs:
       fail-fast: false
       matrix:
         settings:
-          - platform: "macos-latest"
-            args: "--target aarch64-apple-darwin"
-            target: "aarch64-apple-darwin"
-          - platform: "macos-latest"
-            args: "--target x86_64-apple-darwin"
-            target: "x86_64-apple-darwin"
-          - platform: "ubuntu-22.04"
-            args: ""
-            target: ""
+          - platform: 'macos-latest'
+            args: '--target aarch64-apple-darwin'
+            target: 'aarch64-apple-darwin'
+          - platform: 'macos-latest'
+            args: '--target x86_64-apple-darwin'
+            target: 'x86_64-apple-darwin'
+          - platform: 'ubuntu-22.04'
+            args: ''
+            target: ''
     runs-on: ${{ matrix.settings.platform }}
     steps:
       - name: Checkout
@@ -191,7 +189,7 @@ jobs:
         uses: actions/setup-node@v4
         with:
           node-version: 24.x
-          cache: "yarn"
+          cache: 'yarn'
 
       - name: Install Rust stable
         uses: dtolnay/rust-toolchain@stable
@@ -307,14 +305,14 @@ jobs:
           # macOS 10.15+ required for std::filesystem used by llama.cpp
           MACOSX_DEPLOYMENT_TARGET: ${{ matrix.settings.platform == 'macos-latest' && '10.15' || '' }}
         with:
-          args: "-c ${{ steps.config-overrides.outputs.json }} ${{ matrix.settings.args }}"
+          args: '-c ${{ steps.config-overrides.outputs.json }} ${{ matrix.settings.args }}'
           includeDebug: ${{ needs.get-version.outputs.should-publish == '' && inputs.forceRelease != 'true' }}
           includeRelease: ${{ needs.get-version.outputs.should-publish != '' || inputs.forceRelease == 'true' }}
           # TDLib dylibs are now bundled natively via build.rs + tauri.conf.json macOS.frameworks
           # No post-build scripts needed - Tauri bundler handles copying and signing
           releaseId: ${{ needs.create-release.outputs.releaseId }}
-          owner: alphahumanxyz
-          repo: alphahuman
+          owner: openhumanxyz
+          repo: openhuman
 
       - name: Get file info
         id: file-info

.github/workflows/release.yml

@@ -214,7 +214,7 @@ jobs:
           - platform: macos-latest
             args: --target x86_64-apple-darwin
           - platform: ubuntu-22.04
-            args: ""
+            args: ''
     env:
       GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
     steps:
@@ -263,7 +263,7 @@ jobs:
         env:
           BASE_URL: ${{ vars.BASE_URL }}
           UPDATER_PUBLIC_KEY: ${{ secrets.UPDATER_PUBLIC_KEY }}
-          WITH_UPDATER: "true"
+          WITH_UPDATER: 'true'
         with:
           script: |
             const workspacePath = process.env.GITHUB_WORKSPACE.replace(/\\/g, '/');
@@ -293,7 +293,7 @@ jobs:
           BASE_URL: ${{ vars.BASE_URL }}
           TAURI_SIGNING_PRIVATE_KEY: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY }}
           TAURI_SIGNING_PRIVATE_KEY_PASSWORD: ${{ secrets.TAURI_SIGNING_PRIVATE_KEY_PASSWORD }}
-          WITH_UPDATER: "true"
+          WITH_UPDATER: 'true'
           MACOSX_DEPLOYMENT_TARGET: ${{ matrix.settings.platform == 'macos-latest' && '10.15' || '' }}
         with:
           args: -c ${{ steps.config-overrides.outputs.json }} ${{ matrix.settings.args }}

.github/workflows/test.yml

@@ -26,7 +26,7 @@ jobs:
         uses: actions/setup-node@v4
         with:
           node-version: 24.x
-          cache: "yarn"
+          cache: 'yarn'
 
       - name: Cache node modules
         id: yarn-cache

CLAUDE.md

@@ -51,7 +51,7 @@ yarn dev:app
 yarn tauri build
 
 # Debug build with .app bundle (required for deep link testing on macOS)
-# On macOS, alphahuman:// only works when running the .app, not `tauri dev`
+# On macOS, openhuman:// only works when running the .app, not `tauri dev`
 yarn tauri build --debug --bundles app
 yarn macos:dev
 
@@ -133,10 +133,10 @@ Model Context Protocol implementation for AI tool execution over Socket.io:
 
 ### Deep Link Auth Flow
 
-Web-to-desktop handoff using `alphahuman://` URL scheme:
+Web-to-desktop handoff using `openhuman://` URL scheme:
 
 1. User authenticates in browser
-2. Browser redirects to `alphahuman://auth?token=<loginToken>`
+2. Browser redirects to `openhuman://auth?token=<loginToken>`
 3. Tauri catches the deep link, Rust `exchange_token` command calls backend via `reqwest` (bypasses CORS)
 4. Backend returns `sessionToken` + user object
 5. App stores session in Redux, navigates to onboarding/home
@@ -209,18 +209,18 @@ Advanced JavaScript execution engine for skills using V8 (via deno_core):
 
 Set in `.env` (Vite exposes `VITE_*` prefixed vars):
 
-| Variable                     | Purpose                                                             |
-| ---------------------------- | ------------------------------------------------------------------- |
-| `VITE_BACKEND_URL`           | Backend API URL (default: `http://localhost:5005`)                  |
-| `VITE_SENTRY_DSN`            | Sentry DSN for error reporting (optional)                           |
-| `VITE_DEBUG`                 | Debug mode flag                                                     |
-| `ALPHAHUMAN_DAEMON_INTERNAL` | Force internal daemon mode (default: false, uses external services) |
+| Variable                    | Purpose                                                             |
+| --------------------------- | ------------------------------------------------------------------- |
+| `VITE_BACKEND_URL`          | Backend API URL (default: `http://localhost:5005`)                  |
+| `VITE_SENTRY_DSN`           | Sentry DSN for error reporting (optional)                           |
+| `VITE_DEBUG`                | Debug mode flag                                                     |
+| `OPENHUMAN_DAEMON_INTERNAL` | Force internal daemon mode (default: false, uses external services) |
 
 Production defaults are in `src/utils/config.ts`.
 
 ## AI Configuration System
 
-AlphaHuman uses an OpenClaw-compliant AI configuration system that automatically injects persona and tool context into every user message for consistent AI behavior.
+OpenHumanuses an OpenClaw-compliant AI configuration system that automatically injects persona and tool context into every user message for consistent AI behavior.
 
 ### Configuration Files
 
@@ -279,7 +279,7 @@ const toolsMessage = await injectTools(userMessage);
 
 ```
 [PERSONA_CONTEXT]
-I am AlphaHuman: that incredibly smart, funny friend who loves helping people get stuff done
+I am OpenHuman that incredibly smart, funny friend who loves helping people get stuff done
 Personality: Curious & Enthusiastic, Witty & Engaging, Empathetic
 Voice: Conversational, Use humor naturally but don't force it
 [/PERSONA_CONTEXT]
@@ -406,9 +406,9 @@ Key updates from recent commits (cd9ebcd to current):
   - Session capture and transcript management
   - Memory chunking and context formatting
 - **Enhanced CI/CD Pipeline** (`b1d7bce`): Production-ready deployment
-  - XGH_TOKEN authentication for alphahumanxyz/alphahuman releases
+  - XGH_TOKEN authentication for openhumanxyz/openhuman releases
   - Python sidecar setup and caching for cross-platform builds
-  - Tauri configuration updates (com.alphahuman.app identifier)
+  - Tauri configuration updates (com.openhuman.app identifier)
   - GitHub Pages deployment with optimized workflows
   - Version tagging and environment variable management
 - **Device Detection & Download System** (`9d74721`, `b5bccd2`): Enhanced multi-architecture download support
@@ -463,9 +463,9 @@ Key updates from recent commits (cd9ebcd to current):
 
 ## Git Workflow
 
-- **Push target**: All pushes go to the **user's private repo** (your fork). Do not push directly to the org repository.
-- **PR target**: All pull requests are opened **from your fork** against the **org's private repo**, targeting the **`develop`** branch (not `main`).
-- **No direct pushes to org**: The org repo does not allow direct pushes. All changes reach the org repo via PRs from your fork.
+- **Repository visibility**: The project is public.
+- **Push target**: Pushes should go to your working branch in the public repository (or your fork if your access model requires it).
+- **PR target**: Open pull requests against the public upstream repository, targeting the **`main`** branch.
 
 ## Key Patterns
 
@@ -496,7 +496,7 @@ Key updates from recent commits (cd9ebcd to current):
 
 ## Platform Gotchas
 
-- **macOS deep links**: Require `.app` bundle (not `tauri dev`). Clear WebKit caches when debugging stale content: `rm -rf ~/Library/WebKit/com.alphahuman.app ~/Library/Caches/com.alphahuman.app`
+- **macOS deep links**: Require `.app` bundle (not `tauri dev`). Clear WebKit caches when debugging stale content: `rm -rf ~/Library/WebKit/com.openhuman.app ~/Library/Caches/com.openhuman.app`
 - **Cargo caching**: May serve stale frontend assets on incremental builds. Run `cargo clean --manifest-path src-tauri/Cargo.toml` if the app shows outdated UI.
 - **`window.__TAURI__`**: Not available at module load time. Use static imports and try/catch around Tauri API calls (not around imports).
 - **Android background services**: RuntimeService requires notification permissions (API 33+) and foreground service type specification (API 34+). Use Android logging (`android_logger`) for debug output in logcat.

CONTRIBUTING.md

@@ -1,4 +1,4 @@
-# Contributing to AlphaHuman
+# Contributing to OpenHuman
 
 Thank you for your interest in contributing. This document explains how to get set up, follow our workflow, and submit changes.
 
@@ -19,7 +19,7 @@ This project adheres to the [Contributor Covenant Code of Conduct](CODE_OF_CONDU
 ## Getting Started
 
 - Read the [README](README.md) and [ARCHITECTURE](ARCHITECTURE.md) for context.
-- Check [open issues](https://github.com/alphahumanxyz/alphahuman/issues) and discussions for ideas and to avoid duplicate work.
+- Check [open issues](https://github.com/tinyhumansai/openhuman/issues) and discussions for ideas and to avoid duplicate work.
 - For security issues, see [SECURITY.md](SECURITY.md) — do not report vulnerabilities in public issues.
 
 ## Development Setup
@@ -33,8 +33,8 @@ This project adheres to the [Contributor Covenant Code of Conduct](CODE_OF_CONDU
 ### Clone and Install
 
 ```bash
-git clone https://github.com/YOUR_USERNAME/alphahuman.git
-cd alphahuman
+git clone https://github.com/YOUR_USERNAME/openhuman.git
+cd openhuman
 yarn install
 ```
 
@@ -55,7 +55,7 @@ Copy or create a `.env` from the documented template and set `VITE_BACKEND_URL`,
 
 ## Git Workflow
 
-- **Fork** the [alphahuman](https://github.com/alphahumanxyz/alphahuman) repository and work in your fork.
+- **Fork** the [openhuman](https://github.com/tinyhumansai/openhuman) repository and work in your fork.
 - **Base branch**: All pull requests must target the **`develop`** branch (not `main`).
 - **No direct pushes** to the organization repo; all changes come in via pull requests from forks.
 
@@ -69,7 +69,7 @@ Use short, descriptive branches, e.g.:
 
 ## Making Changes
 
-1. Create a branch from `develop`:  
+1. Create a branch from `develop`:
    `git checkout develop && git pull origin develop && git checkout -b fix/your-change`
 2. Make your changes. Keep commits focused and messages clear (e.g., “Fix socket reconnect on network drop”).
 3. Follow our [project conventions](#project-conventions) and run checks before pushing.
@@ -85,9 +85,9 @@ Pre-commit/pre-push hooks (Husky) run formatting and linting; fix any failures b
 
 ## Submitting Changes
 
-1. Push your branch to your fork:  
+1. Push your branch to your fork:
    `git push origin fix/your-change`
-2. Open a **pull request** against **`develop`** in the [alphahuman](https://github.com/alphahumanxyz/alphahuman) repository.
+2. Open a **pull request** against **`develop`** in the [openhuman](https://github.com/tinyhumansai/openhuman) repository.
 3. Fill in the PR template (if present): describe what changed, why, and how to test.
 4. Link any related issues (e.g., “Fixes #123”).
 5. Address review feedback and keep the PR up to date with `develop` (rebase or merge as the project prefers).
@@ -108,4 +108,4 @@ For more detail on architecture, patterns, and platform notes, see the project
 
 ---
 
-Thank you for contributing to AlphaHuman.
+Thank you for contributing to OpenHuman.

SECURITY.md

@@ -2,7 +2,7 @@
 
 ## Supported Versions
 
-We provide security updates for the following versions of AlphaHuman:
+We provide security updates for the following versions of OpenHuman:
 
 | Version        | Supported          |
 | -------------- | ------------------ |
@@ -10,7 +10,7 @@ We provide security updates for the following versions of AlphaHuman:
 | Previous minor | :white_check_mark: |
 | Older          | :x:                |
 
-We recommend always running the [latest release](https://github.com/alphahumanxyz/alphahuman/releases/latest). AlphaHuman is in early beta; older versions may not receive patches.
+We recommend always running the [latest release](https://github.com/tinyhumansai/openhuman/releases/latest). OpenHuman is in early beta; older versions may not receive patches.
 
 ## Reporting a Vulnerability
 
@@ -19,7 +19,7 @@ We take security seriously. If you believe you have found a security vulnerabili
 ### How to Report
 
 1. **Do not** open a public GitHub issue for security vulnerabilities.
-2. Email the maintainers with a clear description of the issue, steps to reproduce, and impact. You can reach us via the contact details listed in the [AlphaHuman organization](https://github.com/alphahumanxyz) or repository.
+2. Email the maintainers with a clear description of the issue, steps to reproduce, and impact. You can reach us via the contact details listed in the [OpenHuman organization](https://github.com/openhumanxyz) or repository.
 3. Include as much detail as possible (platform, version, configuration) so we can reproduce and triage quickly.
 
 ### What to Expect
@@ -38,7 +38,7 @@ We are especially interested in:
 - Issues in dependency chain (npm, Cargo) that affect our build or runtime
 - Platform-specific issues (macOS, Windows, Linux, Android, iOS) that compromise user data or device security
 
-Out-of-scope for this process: general bugs, feature requests, and issues in third-party services we integrate with (e.g., Telegram, Notion) unless they are specific to how AlphaHuman uses them.
+Out-of-scope for this process: general bugs, feature requests, and issues in third-party services we integrate with (e.g., Telegram, Notion) unless they are specific to how OpenHuman uses them.
 
 ### Safe Harbor
 
@@ -50,4 +50,4 @@ We support safe harbor for security researchers who report in good faith. We wil
 - **Data**: Message content is processed on request and not retained for training or long-term storage.
 - **Skills**: Skills run in a sandboxed environment with defined boundaries; we review skill behavior and dependencies where possible.
 
-Thank you for helping keep AlphaHuman and its users safe.
+Thank you for helping keep OpenHuman and its users safe.

docs/ARCHITECTURE.md

@@ -1,8 +1,8 @@
-# AlphaHuman Architecture
+# OpenHuman Architecture
 
 **AI-powered super assistant for crypto communities, built on Rust.**
 
-AlphaHuman is a cross-platform communication and automation platform purpose-built for the cryptocurrency ecosystem. A single React + Rust (Tauri) codebase can target multiple platforms; **what we document and ship for users today is desktop only** — **Windows, macOS, and Linux**. Android, iOS, and web are **not** supported in current docs or releases. The stack includes a sandboxed JavaScript skills engine, persistent Rust-native WebSocket infrastructure, and an AI tool protocol that lets language models invoke any connected service in real time.
+OpenHuman is a cross-platform communication and automation platform purpose-built for the cryptocurrency ecosystem. A single React + Rust (Tauri) codebase can target multiple platforms; **what we document and ship for users today is desktop only** — **Windows, macOS, and Linux**. Android, iOS, and web are **not** supported in current docs or releases. The stack includes a sandboxed JavaScript skills engine, persistent Rust-native WebSocket infrastructure, and an AI tool protocol that lets language models invoke any connected service in real time.
 
 ---
 
@@ -13,7 +13,7 @@ AlphaHuman is a cross-platform communication and automation platform purpose-bui
 **Not supported yet:** Android, iOS, standalone web client (may exist as experimental targets in the repo; do not treat as product-ready).
 
 ```
-                        AlphaHuman (shipping)
+                        OpenHuman (shipping)
                             |
                          Desktop
                     /      |      \
@@ -65,9 +65,9 @@ The frontend communicates with the Rust core through Tauri's IPC bridge — 47+
 
 ## Rust-Powered Performance
 
-AlphaHuman chose Tauri + Rust over Electron for fundamental performance and security reasons:
+OpenHuman chose Tauri + Rust over Electron for fundamental performance and security reasons:
 
-| Metric                    | AlphaHuman (Tauri + Rust)      | Typical Electron App         |
+| Metric                    | OpenHuman (Tauri + Rust)       | Typical Electron App         |
 | ------------------------- | ------------------------------ | ---------------------------- |
 | Binary size               | ~30 MB                         | ~150 MB+                     |
 | Memory per skill context  | ~1-2 MB (QuickJS)              | ~150 MB+ (Chromium renderer) |
@@ -76,7 +76,7 @@ AlphaHuman chose Tauri + Rust over Electron for fundamental performance and secu
 | Memory safety             | Compile-time guaranteed        | Runtime exceptions           |
 | TLS implementation        | rustls (no OpenSSL dependency) | Chromium's BoringSSL         |
 
-**Why this matters for a crypto platform**: Traders and analysts run AlphaHuman alongside resource-intensive tools — charting software, multiple browser tabs, trading terminals. A 30 MB footprint with sub-500ms startup means the app feels native and stays out of the way. Zero GC pauses means real-time price feeds and alerts are never delayed by memory management.
+**Why this matters for a crypto platform**: Traders and analysts run OpenHuman alongside resource-intensive tools — charting software, multiple browser tabs, trading terminals. A 30 MB footprint with sub-500ms startup means the app feels native and stays out of the way. Zero GC pauses means real-time price feeds and alerts are never delayed by memory management.
 
 The **Tokio async runtime** drives all I/O — WebSocket connections, HTTP requests, file operations, and inter-skill communication — as non-blocking tasks on a thread pool. Thousands of concurrent operations (skill executions, cron jobs, socket events) share a small fixed set of OS threads.
 
@@ -84,7 +84,7 @@ The **Tokio async runtime** drives all I/O — WebSocket connections, HTTP reque
 
 ## Real-Time Socket Infrastructure
 
-AlphaHuman implements a **dual-socket architecture**: a Rust-native WebSocket client on desktop and a JavaScript Socket.io client on web. The Rust implementation survives app backgrounding, operates independently of the WebView, and handles TLS via rustls.
+OpenHuman implements a **dual-socket architecture**: a Rust-native WebSocket client on desktop and a JavaScript Socket.io client on web. The Rust implementation survives app backgrounding, operates independently of the WebView, and handles TLS via rustls.
 
 ```
 Desktop Mode:                          Web Mode:
@@ -119,7 +119,7 @@ The socket connection is **shared across all skills**. When events arrive, the s
 
 ## Skills Runtime Engine
 
-AlphaHuman's defining capability is its **sandboxed JavaScript execution engine** running inside the Rust process. Skills are lightweight automation scripts that extend the platform with custom tools, integrations, and scheduled tasks.
+OpenHuman's defining capability is its **sandboxed JavaScript execution engine** running inside the Rust process. Skills are lightweight automation scripts that extend the platform with custom tools, integrations, and scheduled tasks.
 
 ```
 +---------------------------------------------------------------+
@@ -188,7 +188,7 @@ Skills are synced from a GitHub repository and discovered at runtime. Platform f
 
 ## AI & Tool Protocol (MCP)
 
-AlphaHuman implements the **Model Context Protocol** — a JSON-RPC 2.0 layer over Socket.io that lets AI models discover and invoke tools exposed by skills.
+OpenHuman implements the **Model Context Protocol** — a JSON-RPC 2.0 layer over Socket.io that lets AI models discover and invoke tools exposed by skills.
 
 ```
 User Prompt

docs/src-tauri/01-architecture.md

@@ -2,7 +2,7 @@
 
 ## Overview
 
-The Tauri Rust backend provides native functionality for the AlphaHuman desktop application:
+The Tauri Rust backend provides native functionality for the OpenHuman desktop application:
 
 - System tray with background execution
 - Deep link authentication
@@ -113,7 +113,7 @@ listen("socket:should_connect", (event) => {
 | Plugin                      | Version | Purpose                     |
 | --------------------------- | ------- | --------------------------- |
 | `tauri-plugin-opener`       | 2       | Open URLs in browser        |
-| `tauri-plugin-deep-link`    | 2.0.0   | Handle `alphahuman://` URLs |
+| `tauri-plugin-deep-link`    | 2.0.0   | Handle `openhuman://` URLs |
 | `tauri-plugin-autostart`    | 2       | Launch at login             |
 | `tauri-plugin-notification` | 2       | Native notifications        |
 

docs/src-tauri/02-commands.md

@@ -151,7 +151,7 @@ Open Telegram login widget in browser.
 
 ```typescript
 await invoke("start_telegram_login");
-// Opens ${DEFAULT_BACKEND_URL}/auth/telegram-widget?redirect=alphahuman://auth
+// Opens ${DEFAULT_BACKEND_URL}/auth/telegram-widget?redirect=openhuman://auth
 ```
 
 ### `start_telegram_login_with_url`

docs/src-tauri/README.md

@@ -2,7 +2,7 @@
 
 ## Overview
 
-This documentation covers the Tauri Rust backend for the AlphaHuman desktop application.
+This documentation covers the Tauri Rust backend for the OpenHuman desktop application.
 
 ## Quick Reference
 
@@ -26,7 +26,7 @@ This documentation covers the Tauri Rust backend for the AlphaHuman desktop appl
 ### Existing Implementation (`lib.rs`)
 
 - ✅ System tray with show/hide/quit
-- ✅ Deep link handling (`alphahuman://` scheme)
+- ✅ Deep link handling (`openhuman://` scheme)
 - ✅ Token exchange command (CORS bypass)
 - ✅ Autostart plugin (macOS LaunchAgent)
 - ✅ Window minimize-to-tray on close (macOS)
@@ -120,7 +120,7 @@ impl SocketService {
 1. User clicks "Login with Telegram" in desktop app
    ↓
 2. App opens system browser to:
-   ${BACKEND_URL}/auth/telegram-widget?redirect=alphahuman://auth
+   ${BACKEND_URL}/auth/telegram-widget?redirect=openhuman://auth
    ↓
 3. Backend serves Telegram Login Widget HTML page
    ↓
@@ -128,7 +128,7 @@ impl SocketService {
    ↓
 5. Telegram callback → Backend validates → Creates loginToken
    ↓
-6. Backend redirects to: alphahuman://auth?token={loginToken}
+6. Backend redirects to: openhuman://auth?token={loginToken}
    ↓
 7. Desktop app catches deep link
    ↓
@@ -153,7 +153,7 @@ Returns HTML page with Telegram Login Widget that redirects to the specified sch
 #[tauri::command]
 async fn start_telegram_login(app: AppHandle) -> Result<(), String> {
     // Open browser to Telegram widget page
-    let url = format!("{}/auth/telegram-widget?redirect=alphahuman://auth", BACKEND_URL);
+    let url = format!("{}/auth/telegram-widget?redirect=openhuman://auth", BACKEND_URL);
     opener::open(&url)?;
     Ok(())
 }
@@ -189,7 +189,7 @@ pub struct SessionService {
 }
 
 impl SessionService {
-    const SERVICE: &'static str = "com.alphahuman.app";
+    const SERVICE: &'static str = "com.openhuman.app";
 
     pub fn store_token(&self, token: &str) -> Result<(), Error>;
     pub fn get_token(&self) -> Result<Option<String>, Error>;

docs/src/01-architecture.md

@@ -105,7 +105,7 @@ MCP System:
 ### Authentication Flow (Deep Link)
 
 1. User authenticates in browser → receives `loginToken`
-2. Browser redirects to `alphahuman://auth?token=<loginToken>`
+2. Browser redirects to `openhuman://auth?token=<loginToken>`
 3. Desktop app catches deep link via Tauri plugin
 4. `desktopDeepLinkListener` invokes Rust `exchange_token` command
 5. Rust calls backend `POST /auth/desktop-exchange` (CORS-free)

docs/src/05-pages-routing.md

@@ -366,7 +366,7 @@ import('./utils/desktopDeepLinkListener').then(m => {
 });
 ```
 
-The listener intercepts `alphahuman://auth?token=...` and:
+The listener intercepts `openhuman://auth?token=...` and:
 
 1. Exchanges token via Rust command
 2. Stores session in Redux

docs/src/08-hooks-utils.md

@@ -208,7 +208,7 @@ import { buildAuthDeepLink } from '../utils/deeplink';
 
 // Build URL for browser redirect
 const deepLink = buildAuthDeepLink(loginToken);
-// → "alphahuman://auth?token=abc123"
+// → "openhuman://auth?token=abc123"
 
 // In web frontend after auth:
 window.location.href = deepLink;
@@ -235,7 +235,7 @@ import('./utils/desktopDeepLinkListener').then(m => {
 **What it does:**
 
 1. Listens for `onOpenUrl` events from Tauri deep-link plugin
-2. Parses `alphahuman://auth?token=...` URLs
+2. Parses `openhuman://auth?token=...` URLs
 3. Calls Rust `exchange_token` command (bypasses CORS)
 4. Stores session in Redux
 5. Navigates to `/onboarding` or `/home`

docs/telegram-login-desktop.md

@@ -1,6 +1,6 @@
 # Telegram Login (Web → Desktop Handoff)
 
-This app implements **Telegram login for the desktop (Tauri) client** using a **system-browser auth flow** plus a **custom URL scheme deep link** (`alphahuman://`) to return control back to the desktop app.
+This app implements **Telegram login for the desktop (Tauri) client** using a **system-browser auth flow** plus a **custom URL scheme deep link** (`openhuman://`) to return control back to the desktop app.
 
 ---
 
@@ -8,10 +8,10 @@ This app implements **Telegram login for the desktop (Tauri) client** using a **
 
 1. **User clicks “Continue with Telegram”** inside the desktop app.
 2. The app opens the system browser to the backend:
-   - `GET ${BACKEND_URL}/auth/telegram-widget?redirect=alphahuman://auth`
+   - `GET ${BACKEND_URL}/auth/telegram-widget?redirect=openhuman://auth`
 3. The backend performs Telegram authentication (bot-based login / OAuth-like flow).
 4. On success, the backend generates a **short-lived single-use `loginToken`** and redirects the browser to:
-   - `alphahuman://auth?token=<loginToken>`
+   - `openhuman://auth?token=<loginToken>`
 5. The OS routes that deep link to the installed desktop app.
 6. The desktop app extracts the `token` from the deep link and exchanges it for a **long-lived `sessionToken`** by calling a Rust Tauri command (bypassing CORS):
    - `POST ${BACKEND_URL}/auth/desktop-exchange` with `{ token }`
@@ -41,7 +41,7 @@ export const BACKEND_URL =
 The URL scheme is declared in `src-tauri/tauri.conf.json`:
 
 ```json
-{ "plugins": { "deep-link": { "desktop": { "schemes": ["alphahuman"] } } } }
+{ "plugins": { "deep-link": { "desktop": { "schemes": ["openhuman"] } } } }
 ```
 
 The deep-link plugin is initialized in `src-tauri/src/lib.rs`:
@@ -78,8 +78,8 @@ import('./utils/desktopDeepLinkListener').then(m => {
 
 The deep link handler:
 
-- Accepts only the `alphahuman:` scheme
-- Requires `alphahuman://auth?token=...`
+- Accepts only the `openhuman:` scheme
+- Requires `openhuman://auth?token=...`
 - Calls the Rust command `exchange_token`
 - Stores `sessionToken` in Redux auth state
 - Redirects to `#/onboarding` (HashRouter)
@@ -92,7 +92,7 @@ const handleDeepLinkUrls = async (urls: string[] | null | undefined) => {
   try {
     const parsed = new URL(url);
 <<<<<<< HEAD
-    if (parsed.protocol !== 'alphahuman:') return;
+    if (parsed.protocol !== 'openhuman:') return;
     if (parsed.hostname !== 'auth') return;
 =======
     if (parsed.protocol !== "outsourced:") return;
@@ -141,13 +141,13 @@ async fn exchange_token(backend_url: String, token: String) -> Result<serde_json
 
 Your backend must implement **both**:
 
-### A) `GET /auth/telegram-widget?redirect=alphahuman://auth`
+### A) `GET /auth/telegram-widget?redirect=openhuman://auth`
 
 - **Purpose**: start Telegram auth in the user’s browser.
 - **On success**:
   - create/find user
   - mint a **short-lived** `loginToken` (single-use, recommended TTL \(\le 5\) minutes)
-  - redirect to: `alphahuman://auth?token=<loginToken>`
+  - redirect to: `openhuman://auth?token=<loginToken>`
 
 ### B) `POST /auth/desktop-exchange`
 
@@ -180,7 +180,7 @@ Your backend must implement **both**:
 
 ### Backend (required)
 
-- **Implement `GET /auth/telegram?platform=desktop`** and ensure it redirects to `alphahuman://auth?token=...` on success.
+- **Implement `GET /auth/telegram?platform=desktop`** and ensure it redirects to `openhuman://auth?token=...` on success.
 - **Implement `POST /auth/desktop-exchange`** to exchange the login token for a session token.
 - **Enforce security**:
   - `loginToken` is **single-use**
@@ -190,7 +190,7 @@ Your backend must implement **both**:
 ### Desktop app (required for reliable behavior)
 
 - **Ensure the deep-link plugin is configured and permitted**:
-  - `src-tauri/tauri.conf.json` includes `"schemes": ["alphahuman"]`
+  - `src-tauri/tauri.conf.json` includes `"schemes": ["openhuman"]`
   - `src-tauri/capabilities/default.json` includes `"deep-link:default"`
 - **Use a real backend URL**:
   - set `VITE_BACKEND_URL` for dev/prod so `Login.tsx` opens the correct domain
@@ -198,7 +198,7 @@ Your backend must implement **both**:
 ### Desktop app (recommended hardening / cleanup)
 
 - **Validate the deep link target more strictly** in `src/utils/desktopDeepLinkListener.ts`:
-  - today it checks only `parsed.protocol === 'alphahuman:'`
+  - today it checks only `parsed.protocol === 'openhuman:'`
   - recommended: also require `parsed.hostname === 'auth'` (and optionally a known path)
 - **Don’t skip Telegram auth in onboarding**:
   - `src/pages/onboarding/Step1Phone.tsx` currently has a “Continue with Telegram” button that _only navigates_ and does not authenticate.

eslint.config.js

@@ -42,6 +42,8 @@ export default [
       globals: {
         // Browser globals
         window: 'readonly',
+        localStorage: 'readonly',
+        sessionStorage: 'readonly',
         document: 'readonly',
         navigator: 'readonly',
         console: 'readonly',

gitbooks/README.md

@@ -1,34 +1,34 @@
 ---
 description: >-
-  AlphaHuman is a personal AI assistant that runs natively across desktop,
+  OpenHuman is a personal AI assistant that runs natively across desktop,
   mobile, and web that connects your communication platforms, tools, and
   workflows into a single intelligence layer you control.
 icon: diamond
 ---
 
-# Welcome to AlphaHuman
+# Welcome to OpenHuman
 
-AlphaHuman is the first open-source AI agent with Big Data capabilities and a personalized subconscious mind. Built on the OpenClaw architecture and licensed under GNU GPL3, AlphaHuman is designed to close the gap between what AI models can do and what they actually know about you.
+OpenHuman is the first open-source AI agent with Big Data capabilities and a personalized subconscious mind. Built on the OpenClaw architecture and licensed under GNU GPL3, OpenHuman is designed to close the gap between what AI models can do and what they actually know about you.
 
 Every AI model in the world, all 200+ of them, shares the same fundamental limitation. They are stateless. You type a prompt, get a response, and the context evaporates. Even the ones with "memory" store a few bullet points. A few bullet points is a sticky note, not intelligence.
 
-AlphaHuman solves this with two core innovations:
+OpenHuman solves this with two core innovations:
 
 <figure><img src=".gitbook/assets/V02 — Two Innovations@2x.png" alt=""><figcaption></figcaption></figure>
 
 **Neocortex**, a human-like memory engine that can accurately work with over 1 billion tokens. Neocortex indexes 10 million tokens in under 10 seconds, costs $1 to index 5 million tokens, and runs on a MacBook Air CPU with zero LLM dependency. Neocortex goes beyond vector databases. It understands time, entities, and relationships, and it models memory the way the human brain does: by compressing, forgetting strategically, and building knowledge graphs.
 
-**A personalized subconscious system** inspired by the Purkinje cell, a specialized neuron in the human brain responsible for random thoughts and consciousness. AlphaHuman's subconscious triggers over 10,000 memory recall loops per day for under $1, producing proactive insights, pattern recognition, and emergent "thoughts" that feed into a self-learning loop.
+**A personalized subconscious system** inspired by the Purkinje cell, a specialized neuron in the human brain responsible for random thoughts and consciousness. OpenHuman's subconscious triggers over 10,000 memory recall loops per day for under $1, producing proactive insights, pattern recognition, and emergent "thoughts" that feed into a self-learning loop.
 
-Together, these systems turn AlphaHuman into something fundamentally different from a chatbot. It is an AI agent that consumes large amounts of personal data at low cost, maintains a persistent and evolving understanding of your world, and takes proactive actions on your behalf.
+Together, these systems turn OpenHuman into something fundamentally different from a chatbot. It is an AI agent that consumes large amounts of personal data at low cost, maintains a persistent and evolving understanding of your world, and takes proactive actions on your behalf.
 
 {% hint style="info" %}
-AlphaHuman is not AGI. But it is a meaningful architectural step closer to it, with better memory and better orchestration for memory, taking direct inspiration from the human brain.
+OpenHuman is not AGI. But it is a meaningful architectural step closer to it, with better memory and better orchestration for memory, taking direct inspiration from the human brain.
 {% endhint %}
 
-## What AlphaHuman does
+## What OpenHuman does
 
-AlphaHuman connects to your communication platforms, tools, and workflows, and compresses that information into structured intelligence any AI can act on.
+OpenHuman connects to your communication platforms, tools, and workflows, and compresses that information into structured intelligence any AI can act on.
 
 It **compresses context** across your connected sources, turning millions of tokens of organizational noise into a structured knowledge graph of entities, relationships, and temporal chains.
 
@@ -38,29 +38,27 @@ It **thinks proactively** through its subconscious system, making connections an
 
 It **preserves privacy** by design. Raw data stays on your device. Encryption keys never leave the device. Only compressed metadata and summaries are processed server-side.
 
-
-
 ## Who it's for
 
-AlphaHuman is built for people and teams who operate across many conversations and tools, and feel the cost of it.
+OpenHuman is built for people and teams who operate across many conversations and tools, and feel the cost of it.
 
-* **Developers and power users** in the AI ecosystem, especially those using OpenClaw, CrewAI, and similar agentic frameworks, who need a memory and context layer that actually scales.
-* **High-volume communicators** who miss decisions, context, and follow-ups buried in message noise across multiple platforms.
-* **Traders and analysts** who need fast signal extraction and risk awareness across information channels, both on-chain and off-chain.
-* **Distributed teams** who make decisions in chat but need structured follow-through in external tools.
+- **Developers and power users** in the AI ecosystem, especially those using OpenClaw, CrewAI, and similar agentic frameworks, who need a memory and context layer that actually scales.
+- **High-volume communicators** who miss decisions, context, and follow-ups buried in message noise across multiple platforms.
+- **Traders and analysts** who need fast signal extraction and risk awareness across information channels, both on-chain and off-chain.
+- **Distributed teams** who make decisions in chat but need structured follow-through in external tools.
 
-## What AlphaHuman does not do
+## What OpenHuman does not do
 
-AlphaHuman does not claim to be AGI. It does not send messages automatically or impersonate you. It does not store your raw message data long-term. It does not train on your data.
+OpenHuman does not claim to be AGI. It does not send messages automatically or impersonate you. It does not store your raw message data long-term. It does not train on your data.
 
 {% hint style="info" %}
 Privacy is a core architectural decision, not a checkbox. The full privacy design is covered in Privacy & Security.
 {% endhint %}
 
-## How to think about AlphaHuman
+## How to think about OpenHuman
 
 Think of it this way: ChatGPT, Claude, Gemini, and every other model are the brain. They are brilliant at reasoning, generation, and analysis. But they are amnesiac. They know nothing about your actual life.
 
-AlphaHuman is the memory and the subconscious that makes those brains actually useful. It is the Big Data layer for AI: an always-on context engine that compresses your entire organizational life into intelligence any AI can act on.
+OpenHuman is the memory and the subconscious that makes those brains actually useful. It is the Big Data layer for AI: an always-on context engine that compresses your entire organizational life into intelligence any AI can act on.
 
-Your AI is smart. It just does not know you. AlphaHuman fixes that.
+Your AI is smart. It just does not know you. OpenHuman fixes that.

gitbooks/SUMMARY.md

@@ -2,33 +2,33 @@
 
 ## Overview
 
-* [Welcome to AlphaHuman](README.md)
-* [How It Works](overview/how-it-works.md)
-* [Getting Started](overview/getting-started.md)
+- [Welcome to OpenHuman](README.md)
+- [How It Works](overview/how-it-works.md)
+- [Getting Started](overview/getting-started.md)
 
 ## Technology
 
-* [Neocortex](technology/neocortex.md)
-* [The Subconscious](technology/the-subconscious.md)
-* [Architecture](technology/architecture.md)
+- [Neocortex](technology/neocortex.md)
+- [The Subconscious](technology/the-subconscious.md)
+- [Architecture](technology/architecture.md)
 
 ## Product
 
-* [Platform & Availability](product/platform.md)
-* [Skills & Integrations](product/skills-and-integrations.md)
-* [Teams & Organizations](product/teams.md)
-* [Privacy & Security](product/privacy-and-security.md)
-* [Pricing](product/pricing.md)
+- [Platform & Availability](product/platform.md)
+- [Skills & Integrations](product/skills-and-integrations.md)
+- [Teams & Organizations](product/teams.md)
+- [Privacy & Security](product/privacy-and-security.md)
+- [Pricing](product/pricing.md)
 
 ## Use Cases
 
-* [Overview](use-cases/overview.md)
+- [Overview](use-cases/overview.md)
 
 ## Resources
 
-* [FAQ & Troubleshooting](resources/faq.md)
+- [FAQ & Troubleshooting](resources/faq.md)
 
 ## Legal
 
-* [Terms & Conditions](legal/terms-of-use.md)
-* [Privacy Policy](legal/privacy-policy.md)
+- [Terms & Conditions](legal/terms-of-use.md)
+- [Privacy Policy](legal/privacy-policy.md)

gitbooks/legal/privacy-policy.md

@@ -67,4 +67,3 @@ Depending on your location, you may have rights to access, correct, delete, rest
 ## Changes to This Policy
 
 We may update this Privacy Policy from time to time. Material changes will be communicated as required by law. Changes will not apply retroactively in a manner that reduces existing privacy protections.
-

gitbooks/overview/getting-started.md

@@ -4,46 +4,46 @@ icon: play
 
 # Getting Started
 
-This section walks you through setting up AlphaHuman and running your first request.
+This section walks you through setting up OpenHuman and running your first request.
 
-AlphaHuman is open source under the GNU GPL3 license. The codebase is available at [github.com/tinyhumansai/alphahuman](https://github.com/tinyhumansai/alphahuman). You can self-host, contribute, or simply use the hosted version.
+OpenHuman is open source under the GNU GPL3 license. The codebase is available at [github.com/tinyhumansai/openhuman](https://github.com/tinyhumansai/openhuman). You can self-host, contribute, or simply use the hosted version.
 
-***
+---
 
 ## Download & Install
 
-AlphaHuman runs natively on:
+OpenHuman runs natively on:
 
-* **macOS** (Intel and Apple Silicon)
-* **Windows** (x64 and ARM64)
-* **Linux** (x64 and ARM64: AppImage and .deb)
-* **Android**
-* **iOS**
-* **Web** (any modern browser)
+- **macOS** (Intel and Apple Silicon)
+- **Windows** (x64 and ARM64)
+- **Linux** (x64 and ARM64: AppImage and .deb)
+- **Android**
+- **iOS**
+- **Web** (any modern browser)
 
-Download the app for your platform from the official AlphaHuman website, or use the web version directly in your browser.
+Download the app for your platform from the official OpenHuman website, or use the web version directly in your browser.
 
 The native app has a small footprint, starts fast, and uses your operating system's secure credential storage. The web version provides the same core functionality when a native install is not practical.
 
-***
+---
 
 ## Create Your Account
 
-When you first open AlphaHuman, you will be asked to sign in. Multiple sign-in options are available, including social login providers.
+When you first open OpenHuman, you will be asked to sign in. Multiple sign-in options are available, including social login providers.
 
 After signing in, you may be placed on a waitlist depending on rollout status. The waitlist is used to manage access during launch and early scaling.
 
 {% hint style="info" %}
-**No permanent lock-in.** Creating an account does not grant AlphaHuman ongoing access to anything. All processing still requires explicit actions from you later.
+**No permanent lock-in.** Creating an account does not grant OpenHuman ongoing access to anything. All processing still requires explicit actions from you later.
 {% endhint %}
 
-***
+---
 
 ## Connect Your First Source
 
-AlphaHuman works by connecting to your existing tools and platforms. Each connection expands your knowledge graph, giving Neocortex more data to compress and reason over. You choose what to connect, and you can revoke access at any time.
+OpenHuman works by connecting to your existing tools and platforms. Each connection expands your knowledge graph, giving Neocortex more data to compress and reason over. You choose what to connect, and you can revoke access at any time.
 
-**Telegram:** Connect your Telegram account to analyze conversations, extract signals, and generate summaries across your chats and groups. AlphaHuman supports the full range of Telegram capabilities: chat management, message search, contact management, group and channel administration, reactions, polls, inline buttons, and more.
+**Telegram:** Connect your Telegram account to analyze conversations, extract signals, and generate summaries across your chats and groups. OpenHuman supports the full range of Telegram capabilities: chat management, message search, contact management, group and channel administration, reactions, polls, inline buttons, and more.
 
 **Notion:** Connect Notion to export structured outputs like summaries, action items, decisions, and workflow records into your workspace.
 
@@ -53,39 +53,39 @@ AlphaHuman works by connecting to your existing tools and platforms. Each connec
 
 All integrations are optional. You can start with one source and add more later. The more sources you connect, the more powerful the intelligence becomes. Each connection is independently revocable.
 
-***
+---
 
 ## Run Your First Request
 
-Once a source is connected, you can start asking AlphaHuman questions using the command input.
+Once a source is connected, you can start asking OpenHuman questions using the command input.
 
 Try prompts like:
 
-* **"Summarize what I missed today"**
-* **"What are the key decisions from this week?"**
-* **"Extract action items from my recent conversations"**
-* **"What topics are trending across my groups?"**
+- **"Summarize what I missed today"**
+- **"What are the key decisions from this week?"**
+- **"Extract action items from my recent conversations"**
+- **"What topics are trending across my groups?"**
 
-AlphaHuman processes only the data needed to answer your request, produces an output, and presents it for your review. If the output feels too broad or too shallow, narrow the scope. Specify a particular conversation, time range, or intent.
+OpenHuman processes only the data needed to answer your request, produces an output, and presents it for your review. If the output feels too broad or too shallow, narrow the scope. Specify a particular conversation, time range, or intent.
 
-***
+---
 
 ## Explore Skills & Integrations
 
-After your first request, explore what else AlphaHuman can do:
+After your first request, explore what else OpenHuman can do:
 
-* **Skills** extend the assistant's capabilities, fetching external data, running scheduled tasks, processing information, and writing outputs to connected tools
-* **Integrations** let you push structured results to Notion, Google Sheets, and other tools
-* **Workflows** turn conversation decisions into trackable actions you can follow through on
+- **Skills** extend the assistant's capabilities, fetching external data, running scheduled tasks, processing information, and writing outputs to connected tools
+- **Integrations** let you push structured results to Notion, Google Sheets, and other tools
+- **Workflows** turn conversation decisions into trackable actions you can follow through on
 
 Learn more in [Skills & Integrations](../product/skills-and-integrations.md).
 
-***
+---
 
 #### Join the Community
 
-AlphaHuman is in early alpha. Feedback and contributions make a real difference at this stage.
+OpenHuman is in early alpha. Feedback and contributions make a real difference at this stage.
 
 Join the Discord community to connect with other users, share feedback, report issues, and contribute to the project. Early users get free usage as part of the alpha program.
 
-**GitHub:** [github.com/tinyhumansai/alphahuman](https://github.com/tinyhumansai/alphahuman)
+**GitHub:** [github.com/tinyhumansai/openhuman](https://github.com/tinyhumansai/openhuman)

gitbooks/overview/how-it-works.md

@@ -4,9 +4,9 @@ icon: brain
 
 # How It Works
 
-AlphaHuman is built on three technology pillars: a memory engine called Neocortex, a subconscious system inspired by human neuroscience, and a privacy-preserving architecture that keeps raw data on your device. Understanding how these work together is understanding how AlphaHuman thinks.
+OpenHuman is built on three technology pillars: a memory engine called Neocortex, a subconscious system inspired by human neuroscience, and a privacy-preserving architecture that keeps raw data on your device. Understanding how these work together is understanding how OpenHuman thinks.
 
-### The problem AlphaHuman solves
+### The problem OpenHuman solves
 
 Current AI systems fall into the category of Artificial Narrow Intelligence (ANI). They perform well within bounded domains, but they depend on carefully designed architectures and human-defined operational boundaries. They lack three things needed to get closer to general intelligence: persistent memory at scale, a form of consciousness or instinct, and the ability to ingest data without becoming inaccurate or expensive.
 
@@ -14,7 +14,7 @@ Research from Google's Titans project demonstrates the core issue clearly. As LL
 
 <figure><img src="../.gitbook/assets/V04_The_ANI_Problem@2x.png" alt=""><figcaption></figcaption></figure>
 
-AlphaHuman solves this in two steps.
+OpenHuman solves this in two steps.
 
 #### Step 1: Neocortex, the memory engine
 
@@ -50,13 +50,13 @@ Additional capabilities of Neocortex:
 
 #### Step 2: The personalized subconscious
 
-With good memory and good recall, AlphaHuman can do something no other AI agent does: maintain a personalized subconscious.
+With good memory and good recall, OpenHuman can do something no other AI agent does: maintain a personalized subconscious.
 
 In the human brain, there is a specialized neuron called the Purkinje cell. It is mainly responsible for random thoughts and plays a significant role in consciousness. The human brain has both a conscious and subconscious mind that work together to build intelligence. Most agentic systems follow the conscious mind model only. They wait for instructions and execute them. They cannot think on their own.
 
 <figure><img src="../.gitbook/assets/V07_Purkinje_Cell_to_Subconscious@2x.png" alt=""><figcaption></figcaption></figure>
 
-Inspired by the Purkinje cell, AlphaHuman uses Neocortex to periodically trigger global memory recalls. These recalls are fed into a subconscious loop that produces actions, confirmations, or new connections. Memory recalls are cheap, fast, and happen over 10,000 times a day for less than $1.
+Inspired by the Purkinje cell, OpenHuman uses Neocortex to periodically trigger global memory recalls. These recalls are fed into a subconscious loop that produces actions, confirmations, or new connections. Memory recalls are cheap, fast, and happen over 10,000 times a day for less than $1.
 
 The result is an AI that does not just respond to your prompts. It thinks about your data in the background. It makes connections you did not ask for. It surfaces patterns and risks proactively.
 
@@ -64,7 +64,7 @@ The success metric for the subconscious is what the team calls the "mirror test"
 
 ### How the pieces connect
 
-When you use AlphaHuman, here is what happens:
+When you use OpenHuman, here is what happens:
 
 <figure><img src="../.gitbook/assets/V08_How_Pieces_Connect@2x.png" alt=""><figcaption></figcaption></figure>
 
@@ -74,13 +74,13 @@ When you use AlphaHuman, here is what happens:
 
 **The subconscious runs.** Thousands of recall loops per day surface proactive insights, track evolving patterns, and update the knowledge graph.
 
-**You interact naturally.** Ask anything about your life, your team, your projects. Not general knowledge. Your knowledge. What did your team decide? What is the status? What did you miss? AlphaHuman already knows.
+**You interact naturally.** Ask anything about your life, your team, your projects. Not general knowledge. Your knowledge. What did your team decide? What is the status? What did you miss? OpenHuman already knows.
 
 **Privacy is maintained.** Raw data stays on device, encrypted with AES-256-GCM. Encryption keys never leave the device. Only compressed metadata and summaries are processed server-side.
 
 ### The architecture: OpenClaw foundation
 
-AlphaHuman is built on top of the OpenClaw architecture and is open-sourced under the GNU GPL3 license. The full codebase is publicly available on GitHub.
+OpenHuman is built on top of the OpenClaw architecture and is open-sourced under the GNU GPL3 license. The full codebase is publicly available on GitHub.
 
 The architecture uses multi-agent orchestration, where specialized agents are dynamically spawned for specific tasks rather than relying on one monolithic model. An orchestrator agent manages routing, personality, and context distribution. Specialist agents handle specific domains: communication analysis, document synthesis, task management, trading. These agents execute in parallel, not sequentially, for real-time responsiveness.
 
@@ -88,8 +88,8 @@ All agents share a common compressed context provided by Neocortex. This effecti
 
 ### Limitations
 
-AlphaHuman works with probabilistic models. It may occasionally miss nuance, misinterpret sarcasm, or over-prioritize certain messages. This is more likely in highly informal conversations, fast-moving threads, or contexts with limited data.
+OpenHuman works with probabilistic models. It may occasionally miss nuance, misinterpret sarcasm, or over-prioritize certain messages. This is more likely in highly informal conversations, fast-moving threads, or contexts with limited data.
 
-AlphaHuman is not AGI. It is a meaningful step closer, with better memory and better orchestration for memory, taking inspiration from the human brain. But human judgment still matters. AlphaHuman helps you think faster. It does not think for you.
+OpenHuman is not AGI. It is a meaningful step closer, with better memory and better orchestration for memory, taking inspiration from the human brain. But human judgment still matters. OpenHuman helps you think faster. It does not think for you.
 
 Everything is in early alpha. Feedback and contributions are welcomed.

gitbooks/overview/platform.md

@@ -6,7 +6,7 @@ icon: layer-plus
 
 OpenHuman is a native **desktop** application. It is not a web-only tool, browser extension, or Electron wrapper. It is built for performance, security, and a small footprint on the machines where we officially support it today.
 
-***
+---
 
 ## Supported today: desktop
 
@@ -20,7 +20,7 @@ OpenHuman ships native installers for:
 
 **Android, iOS, and a standalone web client are not supported** in documentation or releases yet. The codebase may contain experimental mobile or web targets; they are out of scope for current user-facing docs.
 
-***
+---
 
 ## Why Native Matters
 
@@ -32,7 +32,7 @@ OpenHuman is built as a native application rather than a web wrapper for three r
 
 **OS-level security.** On desktop platforms, OpenHuman stores credentials in your operating system's secure keychain (macOS Keychain, Windows Credential Manager, Linux Secret Service). Sensitive data never sits in browser storage or plain text files.
 
-***
+---
 
 ## Architecture at a Glance
 
@@ -48,7 +48,7 @@ OpenHuman operates across three layers:
 The intelligence layer is not part of the client application. It performs analysis, coordination, and trust scoring separately from the frontend.
 {% endhint %}
 
-***
+---
 
 ## Real-Time Communication
 
@@ -56,7 +56,7 @@ OpenHuman maintains a persistent connection between the application and the inte
 
 The connection is designed for resilience. If the network drops, OpenHuman reconnects automatically with progressive backoff. There is no manual reconnection process.
 
-***
+---
 
 ## Offline Behavior
 

gitbooks/product/platform.md

@@ -4,13 +4,13 @@ icon: layer-plus
 
 # Platform & Availability
 
-AlphaHuman is a native application that runs on six platforms from a single codebase. It is not a web-only tool, browser extension, or Electron wrapper. It is built for performance, security, and a small footprint on every device you use.
+OpenHuman is a native application that runs on six platforms from a single codebase. It is not a web-only tool, browser extension, or Electron wrapper. It is built for performance, security, and a small footprint on every device you use.
 
-***
+---
 
 ## Six Platforms, One Experience
 
-AlphaHuman compiles to native binaries for each supported platform:
+OpenHuman compiles to native binaries for each supported platform:
 
 | Platform    | Architectures        | Distribution   |
 | ----------- | -------------------- | -------------- |
@@ -23,46 +23,46 @@ AlphaHuman compiles to native binaries for each supported platform:
 
 Your account, connected sources, preferences, and settings sync across all platforms. You can start a request on your desktop and review the output on your phone.
 
-***
+---
 
 ## Why Native Matters
 
-AlphaHuman is built as a native application rather than a web wrapper for three reasons.
+OpenHuman is built as a native application rather than a web wrapper for three reasons.
 
 **Small footprint.** The app is lightweight. A fraction of the size of typical communication tools. It starts in under a second and uses minimal memory, so it stays out of the way when running alongside other demanding applications.
 
 **Fast startup.** There is no browser engine to initialize. The app launches quickly and is ready to accept requests immediately.
 
-**OS-level security.** On desktop platforms, AlphaHuman stores credentials in your operating system's secure keychain (macOS Keychain, Windows Credential Manager, Linux Secret Service). Sensitive data never sits in browser storage or plain text files.
+**OS-level security.** On desktop platforms, OpenHuman stores credentials in your operating system's secure keychain (macOS Keychain, Windows Credential Manager, Linux Secret Service). Sensitive data never sits in browser storage or plain text files.
 
-***
+---
 
 ## Architecture at a Glance
 
-AlphaHuman operates across three layers:
+OpenHuman operates across three layers:
 
 **Application layer.** The native app on your device handles the interface, user input, local state, credential management, and skill execution. This layer is responsible for everything you see and interact with.
 
-**Intelligence layer.** AlphaHuman's analysis, coordination, and intelligence systems run as a secure backend service. When a request requires deeper language processing, it is handled here. This layer is operated and maintained by AlphaHuman.
+**Intelligence layer.** OpenHuman's analysis, coordination, and intelligence systems run as a secure backend service. When a request requires deeper language processing, it is handled here. This layer is operated and maintained by OpenHuman.
 
-**External services.** Connected tools and platforms:Telegram, Notion, Google Sheets, and others are accessed only when you explicitly request it. AlphaHuman acts as a bridge between your sources and the intelligence layer, not as a replacement for any of them.
+**External services.** Connected tools and platforms:Telegram, Notion, Google Sheets, and others are accessed only when you explicitly request it. OpenHuman acts as a bridge between your sources and the intelligence layer, not as a replacement for any of them.
 
 {% hint style="info" %}
 The intelligence layer is not part of the client application. It performs analysis, coordination, and trust scoring separately from the frontend.
 {% endhint %}
 
-***
+---
 
 ## Real-Time Communication
 
-AlphaHuman maintains a persistent connection between the application and the intelligence layer. This means responses arrive in real time as they are generated. You see outputs streaming, not loading.
+OpenHuman maintains a persistent connection between the application and the intelligence layer. This means responses arrive in real time as they are generated. You see outputs streaming, not loading.
 
-The connection is designed for resilience. If the network drops, AlphaHuman reconnects automatically with progressive backoff. There is no manual reconnection process.
+The connection is designed for resilience. If the network drops, OpenHuman reconnects automatically with progressive backoff. There is no manual reconnection process.
 
-***
+---
 
 ## Offline Behavior
 
-AlphaHuman's local state persists on your device. Your preferences, settings, and connected source configurations remain available even when you are offline.
+OpenHuman's local state persists on your device. Your preferences, settings, and connected source configurations remain available even when you are offline.
 
 Full analysis and intelligence features require a network connection, since they depend on the intelligence layer. When connectivity is restored, the app resumes normal operation without requiring you to re-authenticate or reconfigure.

gitbooks/product/pricing.md

@@ -4,19 +4,19 @@ icon: sack-dollar
 
 # Pricing
 
-AlphaHuman is priced as a SaaS product for individuals and teams that rely on high-volume communication and need clarity, coordination, and safety across their tools. Pricing reflects the value of reduced cognitive load and better signal quality, not raw message volume.
+OpenHuman is priced as a SaaS product for individuals and teams that rely on high-volume communication and need clarity, coordination, and safety across their tools. Pricing reflects the value of reduced cognitive load and better signal quality, not raw message volume.
 
-***
+---
 
 ## Individual Plans
 
 Individual plans are designed for power users who want help managing high-volume activity across multiple conversations and connected sources.
 
-Core analysis functionality is included so users can understand AlphaHuman's value before committing. Deeper features, longer context windows, persistent workflows, richer integrations, and advanced intelligence are available in higher tiers.
+Core analysis functionality is included so users can understand OpenHuman's value before committing. Deeper features, longer context windows, persistent workflows, richer integrations, and advanced intelligence are available in higher tiers.
 
 Plans are tiered to allow users to start lightweight and expand as their needs grow.
 
-***
+---
 
 ## Team Plans
 
@@ -26,34 +26,34 @@ Team plans include shared workflows, community-level intelligence, coordination
 
 Individual user privacy is preserved even in shared team environments.
 
-***
+---
 
 ## Credit System
 
-AlphaHuman uses a credit-based system for usage-metered features.
+OpenHuman uses a credit-based system for usage-metered features.
 
-* Credits are consumed when you use analysis, intelligence, and processing features
-* Oldest credits are consumed first, encouraging usage before expiry
-* Credits can be earned through the referral program, in addition to purchase
-* Every credit transaction is tracked in an auditable ledger
+- Credits are consumed when you use analysis, intelligence, and processing features
+- Oldest credits are consumed first, encouraging usage before expiry
+- Credits can be earned through the referral program, in addition to purchase
+- Every credit transaction is tracked in an auditable ledger
 
 Credits provide flexibility as you pay for what you use, and you can supplement your plan with earned credits from referrals.
 
-***
+---
 
 ## Payment Methods
 
-AlphaHuman supports standard and cryptocurrency payment options.
+OpenHuman supports standard and cryptocurrency payment options.
 
-* **Card payments:** Standard subscription billing with the ability to upgrade, downgrade, or cancel at any time
-* **Cryptocurrency:** Alternative payment path for users who prefer crypto
+- **Card payments:** Standard subscription billing with the ability to upgrade, downgrade, or cancel at any time
+- **Cryptocurrency:** Alternative payment path for users who prefer crypto
 
 Changes to your plan take effect immediately. Cancellation does not affect outputs already exported to external tools.
 
-***
+---
 
 ## Access During Launch
 
-During the initial launch phase, access to AlphaHuman may be gated through a waitlist. This is done to manage platform stability and collect feedback from early users.
+During the initial launch phase, access to OpenHuman may be gated through a waitlist. This is done to manage platform stability and collect feedback from early users.
 
 Waitlist access does not imply long-term pricing commitments. Pricing and plan boundaries may evolve during this phase as usage patterns become clearer.

gitbooks/product/privacy-and-security.md

@@ -4,71 +4,71 @@ icon: shield
 
 # Privacy & Security
 
-AlphaHuman operates on a principle of **zero-knowledge intelligence**. The system is architecturally designed so that your raw data never needs to leave your device. Neocortex compresses your data locally into structured metadata and summaries. Only this compressed output is processed server-side. Your AI has months of context about your entire organizational life. Your raw data has never touched our servers.
+OpenHuman operates on a principle of **zero-knowledge intelligence**. The system is architecturally designed so that your raw data never needs to leave your device. Neocortex compresses your data locally into structured metadata and summaries. Only this compressed output is processed server-side. Your AI has months of context about your entire organizational life. Your raw data has never touched our servers.
 
-***
+---
 
 ## Privacy by Design
 
-AlphaHuman operates on a principle of **zero retention** for message content. When you make a request, the relevant data is processed to produce an output, and the source content is discarded afterward.
+OpenHuman operates on a principle of **zero retention** for message content. When you make a request, the relevant data is processed to produce an output, and the source content is discarded afterward.
 
-**No long-term message storage.** AlphaHuman does not maintain a persistent archive of your conversations. Context is reconstructed from your connected sources when needed.
+**No long-term message storage.** OpenHuman does not maintain a persistent archive of your conversations. Context is reconstructed from your connected sources when needed.
 
 **No training on your data.** Your conversations, analysis results, and personal information are never used to train AI models or improve systems. Your data serves you and only you.
 
-**OS-level credential storage.** On desktop platforms, AlphaHuman uses your operating system's secure keychain to store credentials and sensitive tokens. Credentials are never stored in plain text, browser storage, or application-level databases.
+**OS-level credential storage.** On desktop platforms, OpenHuman uses your operating system's secure keychain to store credentials and sensitive tokens. Credentials are never stored in plain text, browser storage, or application-level databases.
 
 **On-device where possible.** Interface rendering, input handling, local state management, and credential operations all happen on your device. Only tasks requiring deeper language processing are handled server-side, under the same privacy constraints.
 
-***
+---
 
 ## Permissions and Access Control
 
-AlphaHuman operates on an **explicit-access model**. It only accesses data when you issue a request, and only the data needed to fulfill that request.
+OpenHuman operates on an **explicit-access model**. It only accesses data when you issue a request, and only the data needed to fulfill that request.
 
 ### Request-Scoped Access
 
-Access is determined by your requests, not by background monitoring. If you ask AlphaHuman to summarize a specific conversation, only that conversation is processed. If you do not reference a source, it is not accessed.
+Access is determined by your requests, not by background monitoring. If you ask OpenHuman to summarize a specific conversation, only that conversation is processed. If you do not reference a source, it is not accessed.
 
-AlphaHuman does not silently expand its access over time. There is no progressive permission creep.
+OpenHuman does not silently expand its access over time. There is no progressive permission creep.
 
 ### Source-Specific Permissions
 
 Each connected source has its own permission scope:
 
-* **Telegram:** Read-only access. AlphaHuman can read messages from conversations you reference in a request. It cannot send messages, edit messages, react, join groups, or act on your behalf.
-* **Notion:** Write access to specific workspaces or pages you approve. AlphaHuman does not read unrelated documents.
-* **Google Sheets:** Write access to specific spreadsheets you approve. AlphaHuman does not read unrelated sheets.
+- **Telegram:** Read-only access. OpenHuman can read messages from conversations you reference in a request. It cannot send messages, edit messages, react, join groups, or act on your behalf.
+- **Notion:** Write access to specific workspaces or pages you approve. OpenHuman does not read unrelated documents.
+- **Google Sheets:** Write access to specific spreadsheets you approve. OpenHuman does not read unrelated sheets.
 
 Integration permissions are limited to what is needed for the specific action you request.
 
 ### User-Initiated Actions Only
 
-Every meaningful operation in AlphaHuman is user-initiated. Summaries, analysis, trust evaluation, workflow creation, and exports all require a direct request. There is no continuous background processing or monitoring.
+Every meaningful operation in OpenHuman is user-initiated. Summaries, analysis, trust evaluation, workflow creation, and exports all require a direct request. There is no continuous background processing or monitoring.
 
 {% hint style="info" %}
-AlphaHuman is idle unless you ask it to do something.
+OpenHuman is idle unless you ask it to do something.
 {% endhint %}
 
-***
+---
 
 ## Revoking Access
 
-You can revoke AlphaHuman's access to any connected source at any time.
+You can revoke OpenHuman's access to any connected source at any time.
 
-* Disconnect a source from your settings
-* Remove integration permissions
-* Stop using the application entirely
+- Disconnect a source from your settings
+- Remove integration permissions
+- Stop using the application entirely
 
-Once access is revoked, AlphaHuman immediately stops processing data from that source. There is no delayed or cached processing after revocation. Previously exported outputs (such as summaries written to Notion or Google Sheets) remain where they were written, but no new processing occurs.
+Once access is revoked, OpenHuman immediately stops processing data from that source. There is no delayed or cached processing after revocation. Previously exported outputs (such as summaries written to Notion or Google Sheets) remain where they were written, but no new processing occurs.
 
-This makes AlphaHuman safe to test, pause, or stop using without residual exposure.
+This makes OpenHuman safe to test, pause, or stop using without residual exposure.
 
-***
+---
 
 ## Security
 
-AlphaHuman implements security at every layer of the system.
+OpenHuman implements security at every layer of the system.
 
 **AES-256-GCM encryption.** All sensitive data stored locally is encrypted using AES-256-GCM. Encryption keys are derived from your credentials and stored in your operating system's secure keychain. Keys never leave the device. Even if server-side infrastructure were compromised, your raw data would remain inaccessible because it was never there.
 
@@ -76,11 +76,11 @@ AlphaHuman implements security at every layer of the system.
 
 **Sandboxed skills.** Each skill runs in its own isolated execution environment with enforced memory and resource limits. Skills cannot access each other's data, the host system's file system, or your credentials.
 
-**Encrypted transit.** All communication between the application and AlphaHuman's servers uses encrypted connections. No data travels in plain text.
+**Encrypted transit.** All communication between the application and OpenHuman's servers uses encrypted connections. No data travels in plain text.
 
 **Short-lived tokens.** Authentication tokens are time-limited and single-use where applicable, reducing the window of exposure if a token is compromised.
 
-***
+---
 
 ## How Neocortex enables privacy
 
@@ -94,32 +94,32 @@ Compression itself becomes the privacy architecture. The raw data never needs to
 
 ## Trust & Risk Intelligence
 
-AlphaHuman includes an intelligence layer designed to help you reason about credibility, information quality, and potential risks across your connected sources.
+OpenHuman includes an intelligence layer designed to help you reason about credibility, information quality, and potential risks across your connected sources.
 
 ### What It Does
 
-**Scam and impersonation signals.** AlphaHuman can surface behavioral patterns associated with scams, impersonation, or coordinated abuse. These signals are derived from patterns observed across contexts, not from individual message content.
+**Scam and impersonation signals.** OpenHuman can surface behavioral patterns associated with scams, impersonation, or coordinated abuse. These signals are derived from patterns observed across contexts, not from individual message content.
 
 **Contextual dynamic trust.** Trust is represented through aggregated artifacts, historical accuracy of claims, consistency of contributions, peer interaction patterns rather than static scores or universal ratings. Trust is always contextual: credibility in one domain does not automatically transfer to another.
 
-**Advisory, not enforcement.** AlphaHuman does not ban users, remove messages, block actions, or enforce moderation decisions. Trust and risk outputs are advisory signals that inform your judgment. You decide how to act on them.
+**Advisory, not enforcement.** OpenHuman does not ban users, remove messages, block actions, or enforce moderation decisions. Trust and risk outputs are advisory signals that inform your judgment. You decide how to act on them.
 
 ### Scope
 
 Trust and risk intelligence operates at different levels:
 
-* **Personal:** Visible only to you. Your own analysis, trust assessments, and risk alerts.
-* **Community:** Aggregated patterns within a group or organization, supporting shared coordination and moderation. Never exposes individual message content.
-* **Network:** Anonymized patterns across the broader AlphaHuman user base, improving early detection of shared risks like recurring scam vectors. 
+- **Personal:** Visible only to you. Your own analysis, trust assessments, and risk alerts.
+- **Community:** Aggregated patterns within a group or organization, supporting shared coordination and moderation. Never exposes individual message content.
+- **Network:** Anonymized patterns across the broader OpenHuman user base, improving early detection of shared risks like recurring scam vectors. 
 
 Information does not move between scopes without abstraction and anonymization.
 
-***
+---
 
 ## Shared Environments
 
-When AlphaHuman is used in team or community settings, privacy remains user-centric.
+When OpenHuman is used in team or community settings, privacy remains user-centric.
 
-AlphaHuman does not grant administrators the ability to read private messages through another user's account. Each user's permissions apply only to their own connected sources.
+OpenHuman does not grant administrators the ability to read private messages through another user's account. Each user's permissions apply only to their own connected sources.
 
 Community-level intelligence is derived from aggregated and anonymized signals, not from direct access to individual message content. Shared insights help teams coordinate effectively without compromising individual privacy.

gitbooks/product/skills-and-integrations.md

@@ -4,25 +4,25 @@ icon: screwdriver
 
 # Skills & Integrations
 
-AlphaHuman extends its capabilities through two systems: a **skills engine** that adds new functionality to the assistant, and **integrations** that connect AlphaHuman to external tools. Together, they allow AlphaHuman to do more than analyze conversations; it can fetch data, run scheduled tasks, produce structured outputs, and write results to the tools you already use.
+OpenHuman extends its capabilities through two systems: a **skills engine** that adds new functionality to the assistant, and **integrations** that connect OpenHuman to external tools. Together, they allow OpenHuman to do more than analyze conversations; it can fetch data, run scheduled tasks, produce structured outputs, and write results to the tools you already use.
 
-***
+---
 
 ## Skills Engine
 
-Skills are sandboxed modules that run inside AlphaHuman's native application. Each skill is an isolated unit with its own execution environment, storage, and permissions. Skills extend what the assistant can do without requiring an app update.
+Skills are sandboxed modules that run inside OpenHuman's native application. Each skill is an isolated unit with its own execution environment, storage, and permissions. Skills extend what the assistant can do without requiring an app update.
 
-When you make a request, AlphaHuman's AI automatically discovers which skills are available and decides whether to invoke them based on what you asked for. You do not need to manage skills manually. They are loaded, registered, and made available to the AI system transparently.
+When you make a request, OpenHuman's AI automatically discovers which skills are available and decides whether to invoke them based on what you asked for. You do not need to manage skills manually. They are loaded, registered, and made available to the AI system transparently.
 
 ### What Skills Can Do
 
 Skills operate within defined boundaries. A skill can:
 
-* **Fetch external data:** make HTTP requests to APIs, retrieve information from services, and bring data into AlphaHuman's context
-* **Run on a schedule:** execute at defined intervals using cron-style scheduling, enabling automated monitoring, reporting, or data collection
-* **Process and transform:** analyze, filter, or restructure data within its sandboxed environment, using its own local database for persistence
-* **Write outputs:** produce structured results that the AI can present to you or export through integrations
-* **Respond to events:** react to real-time events from the server, enabling workflows that trigger based on external conditions
+- **Fetch external data:** make HTTP requests to APIs, retrieve information from services, and bring data into OpenHuman's context
+- **Run on a schedule:** execute at defined intervals using cron-style scheduling, enabling automated monitoring, reporting, or data collection
+- **Process and transform:** analyze, filter, or restructure data within its sandboxed environment, using its own local database for persistence
+- **Write outputs:** produce structured results that the AI can present to you or export through integrations
+- **Respond to events:** react to real-time events from the server, enabling workflows that trigger based on external conditions
 
 ### Isolation and Safety
 
@@ -31,20 +31,20 @@ Each skill runs in its own sandboxed environment with enforced resource limits.
 Skills are discovered from a curated registry and filtered by platform compatibility. Only skills that support your current platform are loaded.
 
 {% hint style="info" %}
-Skills extend AlphaHuman's capabilities without requiring trust beyond their declared scope. Each one is isolated, resource-limited, and independently revocable.
+Skills extend OpenHuman's capabilities without requiring trust beyond their declared scope. Each one is isolated, resource-limited, and independently revocable.
 {% endhint %}
 
-***
+---
 
 ## Integrations
 
-Integrations connect AlphaHuman to external tools so structured outputs can live where your team already works. Integrations are not about importing data into AlphaHuman, they are about exporting intelligence out of it.
+Integrations connect OpenHuman to external tools so structured outputs can live where your team already works. Integrations are not about importing data into OpenHuman, they are about exporting intelligence out of it.
 
 ### Supported Integrations
 
-**Telegram:** AlphaHuman connects to your Telegram account to read and analyze conversations, extract signals, summarize discussions, and generate context-aware responses. Access is scoped to the conversations you reference in your requests.
+**Telegram:** OpenHuman connects to your Telegram account to read and analyze conversations, extract signals, summarize discussions, and generate context-aware responses. Access is scoped to the conversations you reference in your requests.
 
-**Notion:** Export summaries, action items, decisions, and workflow records to your Notion workspace. AlphaHuman writes structured documents that preserve the context of where outputs originated. Useful for building shared knowledge bases or living records.
+**Notion:** Export summaries, action items, decisions, and workflow records to your Notion workspace. OpenHuman writes structured documents that preserve the context of where outputs originated. Useful for building shared knowledge bases or living records.
 
 **Google Sheets:** Export tabular data such as logs, reports, extracted metrics, or tracking records. Useful for lightweight analysis, reporting, and audit trails.
 
@@ -52,33 +52,33 @@ These integrations are optional and can be enabled or disabled at any time from
 
 ### How Data Moves
 
-Data moves from AlphaHuman to external tools **only when you explicitly request it**.
+Data moves from OpenHuman to external tools **only when you explicitly request it**.
 
-When a workflow, summary, or analysis is exported, AlphaHuman writes structured data, not raw conversation text. There is no continuous sync, no background polling, and no automatic data transfer. Each export is a deliberate action you initiate.
+When a workflow, summary, or analysis is exported, OpenHuman writes structured data, not raw conversation text. There is no continuous sync, no background polling, and no automatic data transfer. Each export is a deliberate action you initiate.
 
-Integrations are write-oriented by default. AlphaHuman does not read from external tools unless a specific workflow requires it and you have approved that behavior.
+Integrations are write-oriented by default. OpenHuman does not read from external tools unless a specific workflow requires it and you have approved that behavior.
 
 {% hint style="info" %}
-**You control what leaves AlphaHuman.** Nothing is exported to external tools without a clear, user-initiated action.
+**You control what leaves OpenHuman.** Nothing is exported to external tools without a clear, user-initiated action.
 {% endhint %}
 
-***
+---
 
 ## From Conversation to Action
 
-One of AlphaHuman's core capabilities is turning unstructured conversations into structured, actionable outputs.
+One of OpenHuman's core capabilities is turning unstructured conversations into structured, actionable outputs.
 
-When discussions lead to decisions, commitments, or tasks, AlphaHuman can recognize these moments (when you ask it to analyze a conversation) and represent them as **workflows as** structured objects that capture what needs to happen, who is involved, and where the decision came from.
+When discussions lead to decisions, commitments, or tasks, OpenHuman can recognize these moments (when you ask it to analyze a conversation) and represent them as **workflows as** structured objects that capture what needs to happen, who is involved, and where the decision came from.
 
 Workflows link back to the conversations they originated from, preserving intent and rationale. When connected to tools like Notion or Google Sheets, workflows can be exported without duplicating entire conversation histories.
 
-Workflows exist to reduce coordination friction, not to replace dedicated project management systems. AlphaHuman does not auto-assign tasks, enforce deadlines, or create workflows without your input.
+Workflows exist to reduce coordination friction, not to replace dedicated project management systems. OpenHuman does not auto-assign tasks, enforce deadlines, or create workflows without your input.
 
-***
+---
 
 ## Intelligence Concepts
 
-AlphaHuman works by translating raw conversation activity into a small number of structured concepts. These concepts allow the system to reason about communication, coordination, and trust without storing message histories.
+OpenHuman works by translating raw conversation activity into a small number of structured concepts. These concepts allow the system to reason about communication, coordination, and trust without storing message histories.
 
 **Signals:** Structured interpretations extracted from conversations. A signal might represent a decision, warning, important update, or emerging theme. Signals are independent objects that can be filtered, referenced, or aggregated.
 
@@ -88,4 +88,4 @@ AlphaHuman works by translating raw conversation activity into a small number of
 
 **Workflows:** Structured processes that originate from conversation, preserving the context of decisions and commitments as actionable objects.
 
-These concepts allow AlphaHuman to support trust, coordination, and intelligence without becoming invasive or requiring the storage of raw conversation data.
+These concepts allow OpenHuman to support trust, coordination, and intelligence without becoming invasive or requiring the storage of raw conversation data.

gitbooks/product/teams.md

@@ -4,23 +4,23 @@ icon: users
 
 # Teams & Organizations
 
-AlphaHuman supports team workspaces for organizations that need shared access, centralized billing, and coordinated intelligence across members.
+OpenHuman supports team workspaces for organizations that need shared access, centralized billing, and coordinated intelligence across members.
 
-Teams are designed for professional environments where multiple people rely on AlphaHuman and need shared administrative control without compromising individual privacy.
+Teams are designed for professional environments where multiple people rely on OpenHuman and need shared administrative control without compromising individual privacy.
 
-***
+---
 
 ## Team Workspaces
 
-A team workspace is a shared environment where members access AlphaHuman under a unified account structure. Workspaces provide:
+A team workspace is a shared environment where members access OpenHuman under a unified account structure. Workspaces provide:
 
-* **Centralized billing:** one subscription covers all team members, with usage tracked per member
-* **Member management:** invite, remove, and manage team members from a single dashboard
-* **Shared configuration:** team-level settings and preferences that apply across the workspace
+- **Centralized billing:** one subscription covers all team members, with usage tracked per member
+- **Member management:** invite, remove, and manage team members from a single dashboard
+- **Shared configuration:** team-level settings and preferences that apply across the workspace
 
-Each team has a unique identifier and can be managed independently from individual accounts. Users can belong to a team while still maintaining their personal AlphaHuman account and settings.
+Each team has a unique identifier and can be managed independently from individual accounts. Users can belong to a team while still maintaining their personal OpenHuman account and settings.
 
-***
+---
 
 ## Roles and Permissions
 
@@ -30,13 +30,13 @@ Team workspaces support three roles:
 
 **Billing Manager:** Access to billing, payment, and subscription management. Billing Managers can update payment methods, view invoices, and manage the team's plan without access to other administrative functions.
 
-**Member:** Standard access to AlphaHuman within the team workspace. Members use the product normally and benefit from the team subscription, but cannot modify team settings or manage other members.
+**Member:** Standard access to OpenHuman within the team workspace. Members use the product normally and benefit from the team subscription, but cannot modify team settings or manage other members.
 
-***
+---
 
 ## Shared Intelligence
 
-In team environments, AlphaHuman can surface aggregated insights that help the organization operate more effectively.
+In team environments, OpenHuman can surface aggregated insights that help the organization operate more effectively.
 
 **Community trends:** Patterns in conversation activity, topic evolution, and engagement across the team's connected sources, presented in aggregate form.
 
@@ -44,21 +44,21 @@ In team environments, AlphaHuman can surface aggregated insights that help the o
 
 **Engagement insights:** Where coordination stress appears, where follow-through breaks down, and where attention is most needed.
 
-All shared intelligence is derived from aggregated and anonymized signals. AlphaHuman does not give team administrators the ability to read private messages or monitor individual behavior. Each user's personal context remains separate, even within a team workspace.
+All shared intelligence is derived from aggregated and anonymized signals. OpenHuman does not give team administrators the ability to read private messages or monitor individual behavior. Each user's personal context remains separate, even within a team workspace.
 
 {% hint style="info" %}
 **Privacy is preserved in teams.** Shared intelligence is always aggregated. Individual message content and personal analysis remain private to each user.
 {% endhint %}
 
-***
+---
 
 ## Referral Program
 
-AlphaHuman offers a referral system where existing users can invite others and earn credits.
+OpenHuman offers a referral system where existing users can invite others and earn credits.
 
-* Generate a personal invite code from your account settings
-* Share the code with colleagues or collaborators
-* Both the referrer and the new user receive credits when the invitation is accepted
-* Additional credit bonuses may apply when referred users subscribe to a paid plan
+- Generate a personal invite code from your account settings
+- Share the code with colleagues or collaborators
+- Both the referrer and the new user receive credits when the invitation is accepted
+- Additional credit bonuses may apply when referred users subscribe to a paid plan
 
-Referral credits can be used toward AlphaHuman usage across any plan tier.
+Referral credits can be used toward OpenHuman usage across any plan tier.

gitbooks/resources/faq.md

@@ -6,130 +6,130 @@ icon: question
 
 ## Frequently Asked Questions
 
-#### What is AlphaHuman?
+#### What is OpenHuman?
 
-AlphaHuman is a personal AI assistant that connects to your communication platforms and productivity tools. It helps you manage high-volume conversations by summarizing, extracting signals, suggesting responses, and creating structured workflows all from a native app that runs on your device.
+OpenHuman is a personal AI assistant that connects to your communication platforms and productivity tools. It helps you manage high-volume conversations by summarizing, extracting signals, suggesting responses, and creating structured workflows all from a native app that runs on your device.
 
-***
+---
 
 #### What is Neocortex
 
-Neocortex is AlphaHuman's memory engine. It is a human-like AI memory system that can work with over 1 billion tokens of data. It indexes 10 million tokens in under 10 seconds, costs $1 to index 5 million tokens, and runs on a MacBook Air CPU with no GPU required. Unlike vector databases, Neocortex understands time, entities, and relationships. It builds knowledge graphs and manages memory through tiered compression inspired by how the human brain works. Learn more in Neocortex.
+Neocortex is OpenHuman's memory engine. It is a human-like AI memory system that can work with over 1 billion tokens of data. It indexes 10 million tokens in under 10 seconds, costs $1 to index 5 million tokens, and runs on a MacBook Air CPU with no GPU required. Unlike vector databases, Neocortex understands time, entities, and relationships. It builds knowledge graphs and manages memory through tiered compression inspired by how the human brain works. Learn more in Neocortex.
 
-***
+---
 
 #### What does "Big Data AI" mean?
 
-Every AI model today is a prompt engine. You type something, it responds, and the context disappears. AlphaHuman is different. It compresses your entire organizational life, messages, documents, tools, transactions, into a structured knowledge graph that persists and evolves. This is what we mean by Big Data AI: an AI that operates on months of your real data, not just the prompt you typed right now.
+Every AI model today is a prompt engine. You type something, it responds, and the context disappears. OpenHuman is different. It compresses your entire organizational life, messages, documents, tools, transactions, into a structured knowledge graph that persists and evolves. This is what we mean by Big Data AI: an AI that operates on months of your real data, not just the prompt you typed right now.
 
-**How is AlphaHuman different from ChatGPT, Claude, or Gemini?**
+**How is OpenHuman different from ChatGPT, Claude, or Gemini?**
 
-Those models are brilliant at reasoning and generation. But they are stateless. They know nothing about your actual life beyond what you paste into the chat window. AlphaHuman is the context layer that makes those models useful. It compresses your organizational data into structured intelligence that any AI can reason over. Think of it this way: ChatGPT is the brain. AlphaHuman is the memory.
+Those models are brilliant at reasoning and generation. But they are stateless. They know nothing about your actual life beyond what you paste into the chat window. OpenHuman is the context layer that makes those models useful. It compresses your organizational data into structured intelligence that any AI can reason over. Think of it this way: ChatGPT is the brain. OpenHuman is the memory.
 
-***
+---
 
-**How is AlphaHuman different from other AI memory solutions like Mem0, SuperMemory, or MemGPT?**
+**How is OpenHuman different from other AI memory solutions like Mem0, SuperMemory, or MemGPT?**
 
 Most AI memory solutions use vector databases that retrieve whatever is semantically similar, but similarity alone says nothing about importance. They also cannot support consciousness-like systems or process data accurately at scale beyond 10 million tokens. Neocortex is architecturally different: it uses tiered memory, knowledge graphs, temporal weighting, and semantic deduplication. It processes 10 million tokens in under 10 seconds and supports over 1 billion tokens total. It does this with zero LLM dependency.
 
-***
+---
 
-**Is AlphaHuman open source?**
+**Is OpenHuman open source?**
 
-Yes. AlphaHuman is built on the OpenClaw architecture and licensed under GNU GPL3. The full codebase is available on [GitHub](https://github.com/tinyhumansai/alphahuman). Neocortex benchmarks are also open-sourced. Contributions and feedback are welcomed.
+Yes. OpenHuman is built on the OpenClaw architecture and licensed under GNU GPL3. The full codebase is available on [GitHub](https://github.com/tinyhumansai/openhuman). Neocortex benchmarks are also open-sourced. Contributions and feedback are welcomed.
 
-***
+---
 
-**Is AlphaHuman AGI?**
+**Is OpenHuman AGI?**
 
-No. AlphaHuman is not AGI, and we do not claim it is. It is a meaningful architectural step closer to AGI, with innovations in memory (Neocortex) and consciousness-like processing (the subconscious system) that go beyond what existing agentic systems offer. But it operates within defined boundaries and requires human judgment.
+No. OpenHuman is not AGI, and we do not claim it is. It is a meaningful architectural step closer to AGI, with innovations in memory (Neocortex) and consciousness-like processing (the subconscious system) that go beyond what existing agentic systems offer. But it operates within defined boundaries and requires human judgment.
 
-#### Does AlphaHuman read all my messages?
+#### Does OpenHuman read all my messages?
 
-No. AlphaHuman only processes messages **when you ask it to** and only within the scope of your request.
+No. OpenHuman only processes messages **when you ask it to** and only within the scope of your request.
 
 If you ask it to summarize a specific conversation, it reads that conversation. If you do not reference a source, it is not accessed. There is no background monitoring or continuous scanning.
 
-***
+---
 
 #### Is my data safe?
 
-Yes. AlphaHuman is designed around zero retention of message content. Data is processed to produce an output and then discarded. Your conversations are never stored long-term, and they are never used to train AI models.
+Yes. OpenHuman is designed around zero retention of message content. Data is processed to produce an output and then discarded. Your conversations are never stored long-term, and they are never used to train AI models.
 
-On desktop platforms, credentials are stored in your operating system's secure keychain. All communication between the app and AlphaHuman's servers is encrypted.
+On desktop platforms, credentials are stored in your operating system's secure keychain. All communication between the app and OpenHuman's servers is encrypted.
 
-***
+---
 
-#### Does AlphaHuman store my messages?
+#### Does OpenHuman store my messages?
 
 Messages are processed only to fulfill your request. They are **not permanently stored or reused** beyond producing the requested output. Derived intelligence like summaries and workflow records may persist, but raw message content does not.
 
-***
+---
 
-#### Can AlphaHuman send messages on my behalf?
+#### Can OpenHuman send messages on my behalf?
 
-No. AlphaHuman does not auto-send messages, post in your groups, or act on your behalf inside any connected platform. If a reply is suggested, you choose whether to use it.
+No. OpenHuman does not auto-send messages, post in your groups, or act on your behalf inside any connected platform. If a reply is suggested, you choose whether to use it.
 
-***
+---
 
-#### Who is AlphaHuman for?
+#### Who is OpenHuman for?
 
-AlphaHuman is useful for anyone who:
+OpenHuman is useful for anyone who:
 
-* Manages high-volume communication across multiple platforms and groups
-* Needs to stay on top of decisions, action items, and context without reading everything
-* Works in distributed teams, communities, or coordination-heavy environments
-* Wants structured outputs from conversations, exportable to tools like Notion or Google Sheets
+- Manages high-volume communication across multiple platforms and groups
+- Needs to stay on top of decisions, action items, and context without reading everything
+- Works in distributed teams, communities, or coordination-heavy environments
+- Wants structured outputs from conversations, exportable to tools like Notion or Google Sheets
 
 You do not need to be technical to use it.
 
-***
+---
 
-#### What platforms does AlphaHuman support?
+#### What platforms does OpenHuman support?
 
-AlphaHuman runs natively on **macOS, Windows, Linux, Android, and iOS**, with a **web version** for browser access. Your account and settings sync across all platforms.
+OpenHuman runs natively on **macOS, Windows, Linux, Android, and iOS**, with a **web version** for browser access. Your account and settings sync across all platforms.
 
-***
+---
 
 #### What integrations are available?
 
-AlphaHuman currently integrates with **Telegram** (read and analyze conversations), **Notion** (export structured outputs), and **Google Sheets** (export tabular data and reports). More integrations are planned.
+OpenHuman currently integrates with **Telegram** (read and analyze conversations), **Notion** (export structured outputs), and **Google Sheets** (export tabular data and reports). More integrations are planned.
 
-***
+---
 
-#### How much does AlphaHuman cost?
+#### How much does OpenHuman cost?
 
-AlphaHuman offers individual and team plans with core analysis included. Deeper features are available in higher tiers. A credit system provides usage-metered flexibility, and credits can be earned through referrals.
+OpenHuman offers individual and team plans with core analysis included. Deeper features are available in higher tiers. A credit system provides usage-metered flexibility, and credits can be earned through referrals.
 
 See [Pricing](../product/pricing.md) for details.
 
-***
+---
 
 ## Troubleshooting
 
 #### Summaries feel incomplete or too broad
 
-If a summary feels incomplete, the most common cause is overly broad scope. When a request spans many conversations, long time ranges, or high-volume groups, AlphaHuman prioritizes signal over detail.
+If a summary feels incomplete, the most common cause is overly broad scope. When a request spans many conversations, long time ranges, or high-volume groups, OpenHuman prioritizes signal over detail.
 
-**Solution:** Narrow the request to a specific conversation, time window, or intent. AlphaHuman performs best when it knows what kind of outcome you are looking for.
+**Solution:** Narrow the request to a specific conversation, time window, or intent. OpenHuman performs best when it knows what kind of outcome you are looking for.
 
-***
+---
 
 #### Important context seems missing
 
-AlphaHuman only processes the data required to fulfill a request. If relevant context exists outside the scope of that request, it will not be included.
+OpenHuman only processes the data required to fulfill a request. If relevant context exists outside the scope of that request, it will not be included.
 
 **Solution:** Expand the scope explicitly by referencing additional conversations or extending the time range.
 
-***
+---
 
 #### Outputs feel incorrect or misinterpreted
 
-AlphaHuman interprets conversations probabilistically. Tone, sarcasm, and informal language can be misread, especially in fast-moving or meme-heavy discussions.
+OpenHuman interprets conversations probabilistically. Tone, sarcasm, and informal language can be misread, especially in fast-moving or meme-heavy discussions.
 
 **Solution:** Refine the request or re-run analysis with a narrower scope. Outputs should be treated as assistance rather than ground truth.
 
-***
+---
 
 #### Trust or risk signals feel inaccurate
 
@@ -137,23 +137,23 @@ Trust and risk intelligence is indicative, not authoritative. Signals may lag re
 
 **Solution:** Use these signals as inputs into your judgment rather than standalone decisions. Over time, as more outcomes accumulate within the same context, signal quality improves.
 
-***
+---
 
 #### A source does not appear in analysis
 
-AlphaHuman can only analyze sources you have connected and that fall within the scope of your request.
+OpenHuman can only analyze sources you have connected and that fall within the scope of your request.
 
-**Solution:** Ensure the source is connected in your settings and explicitly referenced or selected in your request. AlphaHuman does not automatically include all connected sources by default.
+**Solution:** Ensure the source is connected in your settings and explicitly referenced or selected in your request. OpenHuman does not automatically include all connected sources by default.
 
-***
+---
 
 #### Integrations do not update as expected
 
-Integrations only run when explicitly triggered by your action. AlphaHuman does not continuously sync or poll external tools.
+Integrations only run when explicitly triggered by your action. OpenHuman does not continuously sync or poll external tools.
 
 **Solution:** If an export fails, check that the integration is still connected and that permissions are valid. Retrying the action after resolving any permission or availability issues usually succeeds.
 
-***
+---
 
 #### Performance feels slow
 
@@ -161,18 +161,18 @@ Response time depends on request complexity, data volume, and current system loa
 
 **Solution:** Large scopes and long histories require more processing. Narrowing scope and intent improves responsiveness. During early rollout phases, performance may vary as capacity is tuned.
 
-***
+---
 
 #### Revoking access and residual data
 
-When access to a source or integration is revoked, AlphaHuman immediately stops processing data from that source.
+When access to a source or integration is revoked, OpenHuman immediately stops processing data from that source.
 
-Previously exported outputs (such as summaries written to Notion or Google Sheets) remain where they were written. AlphaHuman does not retain message content after revocation.
+Previously exported outputs (such as summaries written to Notion or Google Sheets) remain where they were written. OpenHuman does not retain message content after revocation.
 
-***
+---
 
 #### When to contact support
 
 If an issue persists after refining scope, checking permissions, and retrying the request, support may be required.
 
-Support is intended for system-level issues, not for disputing interpretations or outcomes. AlphaHuman does not adjudicate trust or risk disagreements.
+Support is intended for system-level issues, not for disputing interpretations or outcomes. OpenHuman does not adjudicate trust or risk disagreements.

gitbooks/technology/architecture.md

@@ -1,10 +1,10 @@
 # Architecture
 
-AlphaHuman is built on the OpenClaw architecture and open-sourced under the GNU GPL3 license. This page explains how the major components connect.
+OpenHuman is built on the OpenClaw architecture and open-sourced under the GNU GPL3 license. This page explains how the major components connect.
 
 #### The three pillars
 
-AlphaHuman's architecture rests on three pillars that work together:
+OpenHuman's architecture rests on three pillars that work together:
 
 <figure><img src="../.gitbook/assets/V15 — Three Pillars@2x.png" alt=""><figcaption></figcaption></figure>
 
@@ -27,14 +27,14 @@ AlphaHuman's architecture rests on three pillars that work together:
 
 #### Model-agnostic design
 
-AlphaHuman is not locked to any single AI model. The compression engine and memory layer sit on top of the AI infrastructure, not inside it. Today the system works with specific models. Tomorrow it could feed context to any model: GPT, Claude, Gemini, Llama, Mistral, or whatever comes next.
+OpenHuman is not locked to any single AI model. The compression engine and memory layer sit on top of the AI infrastructure, not inside it. Today the system works with specific models. Tomorrow it could feed context to any model: GPT, Claude, Gemini, Llama, Mistral, or whatever comes next.
 
-This is a deliberate architectural choice. AI models are commoditizing. Performance is converging. The real differentiator is the context you feed the model, and AlphaHuman owns the context layer.
+This is a deliberate architectural choice. AI models are commoditizing. Performance is converging. The real differentiator is the context you feed the model, and OpenHuman owns the context layer.
 
 #### Open source
 
-AlphaHuman is publicly available on GitHub under the GNU GPL3 license.
+OpenHuman is publicly available on GitHub under the GNU GPL3 license.
 
-**GitHub:** [github.com/tinyhumansai/alphahuman](https://github.com/tinyhumansai/alphahuman) **Neocortex benchmarks:** [github.com/tinyhumansai/neocortex/tree/main/benchmarks](https://github.com/tinyhumansai/neocortex/tree/main/benchmarks)
+**GitHub:** [github.com/tinyhumansai/openhuman](https://github.com/tinyhumansai/openhuman) **Neocortex benchmarks:** [github.com/tinyhumansai/neocortex/tree/main/benchmarks](https://github.com/tinyhumansai/neocortex/tree/main/benchmarks)
 
 Contributions, feedback, and issues are welcomed. The project is in early alpha.

gitbooks/technology/neocortex.md

@@ -1,6 +1,6 @@
 # Neocortex
 
-Neocortex is AlphaHuman's memory engine. It is a human-like AI memory system designed to work accurately with over 1 billion tokens of data while supporting the computational demands of a subconscious system.
+Neocortex is OpenHuman's memory engine. It is a human-like AI memory system designed to work accurately with over 1 billion tokens of data while supporting the computational demands of a subconscious system.
 
 <figure><img src="../.gitbook/assets/V09 — Neocortex Hero@2x.png" alt=""><figcaption></figcaption></figure>
 
@@ -76,7 +76,7 @@ The result: millions of tokens of organizational noise compressed into a structu
 
 #### Neocortex and the subconscious
 
-Neocortex serves as the foundation for AlphaHuman's subconscious, going well beyond retrieval.
+Neocortex serves as the foundation for OpenHuman's subconscious, going well beyond retrieval.
 
 Good memory recall is the prerequisite for consciousness. Neocortex provides this by recalling memories ranked on three factors: time, interactions, and randomness. The randomness element is critical. It is what enables the subconscious system to make unexpected connections and surface emergent insights.
 

gitbooks/technology/the-subconscious.md

@@ -1,6 +1,6 @@
 # The Subconscious
 
-AlphaHuman's subconscious is what separates it from every other AI agent. Most AI systems follow the conscious mind model: they wait for instructions and execute them. They cannot think on their own. AlphaHuman can.
+OpenHuman's subconscious is what separates it from every other AI agent. Most AI systems follow the conscious mind model: they wait for instructions and execute them. They cannot think on their own. OpenHuman can.
 
 #### The Purkinje cell inspiration
 
@@ -8,11 +8,11 @@ In the human brain, there is a specialized neuron called the Purkinje cell. It i
 
 The human brain operates with both a conscious and subconscious mind. The conscious mind handles deliberate, focused tasks. The subconscious processes information in the background, making connections, surfacing memories, and generating the "random" thoughts that often turn out to be the most important ones. Most agentic AI systems only model the conscious mind. They are reactive. They wait for input.
 
-AlphaHuman models both.
+OpenHuman models both.
 
 #### How the subconscious works
 
-Inspired by the Purkinje cell, AlphaHuman uses Neocortex to periodically trigger global memory recalls. Rather than targeted retrievals in response to a specific query, these are broad, semi-random sweeps across the knowledge graph, pulling up memories based on a mix of recency, relevance, and randomness.
+Inspired by the Purkinje cell, OpenHuman uses Neocortex to periodically trigger global memory recalls. Rather than targeted retrievals in response to a specific query, these are broad, semi-random sweeps across the knowledge graph, pulling up memories based on a mix of recency, relevance, and randomness.
 
 These recalls feed into a self-learning loop. The subconscious processes the recalled memories, looks for patterns, contradictions, and connections, and produces one of several outputs: a proactive insight, an action recommendation, a confirmation of an existing pattern, or a new connection between previously unrelated information.
 
@@ -24,7 +24,7 @@ The subconscious does not generate generic AI outputs. It produces context-speci
 
 It might surface a risk you had not noticed: two team members making contradictory commitments in separate conversations. It might connect a trend in your trading data to a discussion from three weeks ago. It might remind you of a commitment you made that is approaching its deadline, before you think to ask.
 
-The outputs are proactive. You do not need to prompt AlphaHuman to get value from the subconscious. It works in the background, feeding insights into the system that are available when you interact.
+The outputs are proactive. You do not need to prompt OpenHuman to get value from the subconscious. It works in the background, feeding insights into the system that are available when you interact.
 
 #### The mirror test
 

gitbooks/use-cases/overview.md

@@ -1,71 +1,71 @@
 # Overview
 
-AlphaHuman adapts to different coordination and information environments across communication platforms. While the underlying system remains the same, the way value is realized depends on how your tools and conversations are used in each context. This section outlines common use cases to help you understand where AlphaHuman fits naturally and where it may offer limited benefit.
+OpenHuman adapts to different coordination and information environments across communication platforms. While the underlying system remains the same, the way value is realized depends on how your tools and conversations are used in each context. This section outlines common use cases to help you understand where OpenHuman fits naturally and where it may offer limited benefit.
 
-***
+---
 
 ## Individual Power Users
 
 Individual power users often participate in many active conversations and channels at once. Important messages are easily missed, and catching up becomes time-consuming and mentally draining.
 
-In this context, AlphaHuman is used to summarize conversations, surface high-signal updates, and provide quick context before responding. Users rely on it to understand what changed, what requires attention, and where follow-ups may be needed without scrolling through entire threads.
+In this context, OpenHuman is used to summarize conversations, surface high-signal updates, and provide quick context before responding. Users rely on it to understand what changed, what requires attention, and where follow-ups may be needed without scrolling through entire threads.
 
 The value here is personal clarity and reduced cognitive load rather than shared coordination.
 
-***
+---
 
 ## Traders and Analysts
 
 Traders and analysts use communication platforms as real-time information sources. Signal quality varies widely, and misinformation, repetition, and scams are common.
 
-AlphaHuman is used to extract claims, track how information resolves over time, and surface signals weighted by historical reliability within context. Risk intelligence helps flag suspicious behavior or repeated failure patterns across groups and channels.
+OpenHuman is used to extract claims, track how information resolves over time, and surface signals weighted by historical reliability within context. Risk intelligence helps flag suspicious behavior or repeated failure patterns across groups and channels.
 
 The outcome is better information filtering and reduced exposure to low-quality or malicious signals not automated trading or execution.
 
-***
+---
 
 ## DAO and Web3 Communities
 
 DAOs and Web3 communities rely heavily on messaging platforms for governance discussions, coordination, and informal decision-making. As these communities grow, accountability and memory become difficult to maintain.
 
-AlphaHuman is used to preserve decisions, track contributions, and support shared workflows without forcing discussions into external tools prematurely. Community-level intelligence helps moderators and operators understand participation patterns and emerging issues.
+OpenHuman is used to preserve decisions, track contributions, and support shared workflows without forcing discussions into external tools prematurely. Community-level intelligence helps moderators and operators understand participation patterns and emerging issues.
 
 The value lies in maintaining continuity and accountability without sacrificing the speed and openness of chat-based coordination.
 
-***
+---
 
 ## Community Managers and Moderators
 
 Community managers and moderators face increasing load as groups scale. Monitoring sentiment, identifying emerging risks, and enforcing consistent standards become harder over time.
 
-AlphaHuman supports these roles by surfacing aggregated insights about group health, contribution patterns, and potential risk signals. It helps moderators focus attention where it matters rather than reacting to volume alone.
+OpenHuman supports these roles by surfacing aggregated insights about group health, contribution patterns, and potential risk signals. It helps moderators focus attention where it matters rather than reacting to volume alone.
 
-AlphaHuman does not replace moderation judgment or enforcement tools. It provides context and early warning signals.
+OpenHuman does not replace moderation judgment or enforcement tools. It provides context and early warning signals.
 
-***
+---
 
 ## Distributed Teams
 
 Distributed teams often use messaging platforms for fast coordination, even when formal work happens elsewhere. Decisions and commitments are made in chat and later forgotten or misinterpreted.
 
-AlphaHuman is used to extract actions, preserve decision context, and sync structured outcomes to tools like Notion or Google Sheets when needed. This reduces friction between discussion and execution without forcing teams to abandon their preferred communication platforms.
+OpenHuman is used to extract actions, preserve decision context, and sync structured outcomes to tools like Notion or Google Sheets when needed. This reduces friction between discussion and execution without forcing teams to abandon their preferred communication platforms.
 
 The benefit is improved follow-through and clarity without heavy process overhead.
 
-***
+---
 
 ## Service Providers and Contributors
 
 Service providers, consultants, and contributors often operate across multiple communities and projects. Building and maintaining reputation is difficult when history is fragmented across conversations and platforms.
 
-AlphaHuman helps surface contribution patterns and trust artifacts that reflect consistent behavior over time. This supports safer collaboration and discovery without requiring centralized profiles or public self-promotion.
+OpenHuman helps surface contribution patterns and trust artifacts that reflect consistent behavior over time. This supports safer collaboration and discovery without requiring centralized profiles or public self-promotion.
 
 The value is portable credibility grounded in behavior rather than claims.
 
-***
+---
 
-## When AlphaHuman Is Not a Good Fit
+## When OpenHuman Is Not a Good Fit
 
-AlphaHuman provides limited value in environments where conversations are purely social, meme-driven, or intentionally ephemeral. It is also not designed for high-frequency trading execution, formal project management, or environments that require strict real-time guarantees.
+OpenHuman provides limited value in environments where conversations are purely social, meme-driven, or intentionally ephemeral. It is also not designed for high-frequency trading execution, formal project management, or environments that require strict real-time guarantees.
 
-Understanding these boundaries helps users apply AlphaHuman where it is strongest.
+Understanding these boundaries helps users apply OpenHuman where it is strongest.

package.json

@@ -15,16 +15,17 @@
     "macos:build:intel:debug": "yarn macos:build:intel --debug",
     "macos:build:debug": "yarn macos:build:release --debug",
     "macos:build:release": "source scripts/load-dotenv.sh && tauri build --bundles app dmg",
-    "macos:build:sign:release": "source scripts/load-env.sh && tauri build --bundles app dmg",
+    "macos:build:release:signed": "source scripts/load-env.sh && tauri build --bundles app dmg",
+    "macos:build:sign:release": "yarn macos:build:release:signed",
     "macos:run": "open 'src-tauri/target/debug/bundle/macos/OpenHuman.app'",
     "macos:dev": "yarn macos:build:debug && open 'src-tauri/target/debug/bundle/macos/OpenHuman.app'",
     "android:dev": "tauri android dev",
     "android:build": "tauri android build",
-    "test": "vitest run",
-    "test:unit": "vitest run",
-    "test:unit:watch": "vitest",
-    "test:watch": "vitest",
-    "test:coverage": "vitest run --coverage",
+    "test": "vitest run --config test/vitest.config.ts",
+    "test:unit": "vitest run --config test/vitest.config.ts",
+    "test:unit:watch": "vitest --config test/vitest.config.ts",
+    "test:watch": "vitest --config test/vitest.config.ts",
+    "test:coverage": "vitest run --config test/vitest.config.ts --coverage",
     "test:rust": "source $HOME/.cargo/env 2>/dev/null; cargo test --manifest-path src-tauri/Cargo.toml",
     "test:e2e:build": "bash scripts/e2e-build.sh",
     "test:e2e:login": "bash scripts/e2e-login.sh",

scripts/ci-event.json

@@ -3,9 +3,9 @@
   "before": "0000000000000000000000000000000000000000",
   "after": "19281e16457e7c8ff8e6bda6ceda77f0880d10d2",
   "repository": {
-    "full_name": "vezuresdotxyz/alphahuman-frontend-runner",
+    "full_name": "vezuresdotxyz/openhuman-frontend-runner",
     "default_branch": "main",
-    "name": "alphahuman-frontend-runner",
+    "name": "openhuman-frontend-runner",
     "owner": { "login": "vezuresdotxyz" }
   },
   "head_commit": {

scripts/e2e-auth.sh

@@ -22,9 +22,9 @@ export BACKEND_URL="http://127.0.0.1:${E2E_MOCK_PORT}"
 # Clean cached app data for a fresh state — Redux Persist would otherwise
 # remember the JWT from a previous run and skip the login flow.
 echo "Cleaning cached app data..."
-rm -rf ~/Library/WebKit/com.alphahuman.app
-rm -rf ~/Library/Caches/com.alphahuman.app
-rm -rf "$HOME/Library/Application Support/com.alphahuman.app"
+rm -rf ~/Library/WebKit/com.openhuman.app
+rm -rf ~/Library/Caches/com.openhuman.app
+rm -rf "$HOME/Library/Application Support/com.openhuman.app"
 
 # Verify the frontend dist has the mock server URL baked in.
 DIST_JS="$(ls dist/assets/index-*.js 2>/dev/null | head -1)"

scripts/e2e-crypto-payment.sh

@@ -22,9 +22,9 @@ export BACKEND_URL="http://127.0.0.1:${E2E_MOCK_PORT}"
 # Clean cached app data for a fresh state — Redux Persist would otherwise
 # remember the JWT from a previous run and skip the login flow.
 echo "Cleaning cached app data..."
-rm -rf ~/Library/WebKit/com.alphahuman.app
-rm -rf ~/Library/Caches/com.alphahuman.app
-rm -rf "$HOME/Library/Application Support/com.alphahuman.app"
+rm -rf ~/Library/WebKit/com.openhuman.app
+rm -rf ~/Library/Caches/com.openhuman.app
+rm -rf "$HOME/Library/Application Support/com.openhuman.app"
 
 # Verify the frontend dist has the mock server URL baked in.
 DIST_JS="$(ls dist/assets/index-*.js 2>/dev/null | head -1)"

scripts/e2e-gmail.sh

@@ -22,9 +22,9 @@ export BACKEND_URL="http://127.0.0.1:${E2E_MOCK_PORT}"
 # Clean cached app data for a fresh state — Redux Persist would otherwise
 # remember the JWT from a previous run and skip the login flow.
 echo "Cleaning cached app data..."
-rm -rf ~/Library/WebKit/com.alphahuman.app
-rm -rf ~/Library/Caches/com.alphahuman.app
-rm -rf "$HOME/Library/Application Support/com.alphahuman.app"
+rm -rf ~/Library/WebKit/com.openhuman.app
+rm -rf ~/Library/Caches/com.openhuman.app
+rm -rf "$HOME/Library/Application Support/com.openhuman.app"
 
 # Verify the frontend dist has the mock server URL baked in.
 DIST_JS="$(ls dist/assets/index-*.js 2>/dev/null | head -1)"

scripts/e2e-login.sh

@@ -24,9 +24,9 @@ export BACKEND_URL="http://127.0.0.1:${E2E_MOCK_PORT}"
 # Clean cached app data for a fresh state — Redux Persist would otherwise
 # remember the JWT from a previous run and skip the login flow.
 echo "Cleaning cached app data..."
-rm -rf ~/Library/WebKit/com.alphahuman.app
-rm -rf ~/Library/Caches/com.alphahuman.app
-rm -rf "$HOME/Library/Application Support/com.alphahuman.app"
+rm -rf ~/Library/WebKit/com.openhuman.app
+rm -rf ~/Library/Caches/com.openhuman.app
+rm -rf "$HOME/Library/Application Support/com.openhuman.app"
 
 # Verify the frontend dist has the mock server URL baked in (not production).
 # Tauri compresses assets when embedding, so we check dist/ not the binary.

scripts/e2e-notion.sh

@@ -22,9 +22,9 @@ export BACKEND_URL="http://127.0.0.1:${E2E_MOCK_PORT}"
 # Clean cached app data for a fresh state — Redux Persist would otherwise
 # remember the JWT from a previous run and skip the login flow.
 echo "Cleaning cached app data..."
-rm -rf ~/Library/WebKit/com.alphahuman.app
-rm -rf ~/Library/Caches/com.alphahuman.app
-rm -rf "$HOME/Library/Application Support/com.alphahuman.app"
+rm -rf ~/Library/WebKit/com.openhuman.app
+rm -rf ~/Library/Caches/com.openhuman.app
+rm -rf "$HOME/Library/Application Support/com.openhuman.app"
 
 # Verify the frontend dist has the mock server URL baked in.
 DIST_JS="$(ls dist/assets/index-*.js 2>/dev/null | head -1)"

scripts/e2e-payment.sh

@@ -22,9 +22,9 @@ export BACKEND_URL="http://127.0.0.1:${E2E_MOCK_PORT}"
 # Clean cached app data for a fresh state — Redux Persist would otherwise
 # remember the JWT from a previous run and skip the login flow.
 echo "Cleaning cached app data..."
-rm -rf ~/Library/WebKit/com.alphahuman.app
-rm -rf ~/Library/Caches/com.alphahuman.app
-rm -rf "$HOME/Library/Application Support/com.alphahuman.app"
+rm -rf ~/Library/WebKit/com.openhuman.app
+rm -rf ~/Library/Caches/com.openhuman.app
+rm -rf "$HOME/Library/Application Support/com.openhuman.app"
 
 # Verify the frontend dist has the mock server URL baked in.
 DIST_JS="$(ls dist/assets/index-*.js 2>/dev/null | head -1)"

scripts/e2e-telegram.sh

@@ -22,9 +22,9 @@ export BACKEND_URL="http://127.0.0.1:${E2E_MOCK_PORT}"
 # Clean cached app data for a fresh state — Redux Persist would otherwise
 # remember the JWT from a previous run and skip the login flow.
 echo "Cleaning cached app data..."
-rm -rf ~/Library/WebKit/com.alphahuman.app
-rm -rf ~/Library/Caches/com.alphahuman.app
-rm -rf "$HOME/Library/Application Support/com.alphahuman.app"
+rm -rf ~/Library/WebKit/com.openhuman.app
+rm -rf ~/Library/Caches/com.openhuman.app
+rm -rf "$HOME/Library/Application Support/com.openhuman.app"
 
 # Verify the frontend dist has the mock server URL baked in.
 DIST_JS="$(ls dist/assets/index-*.js 2>/dev/null | head -1)"

scripts/prepareTauriConfig.js

@@ -8,7 +8,7 @@ export default function prepareTauriConfig() {
   const config = {
     build: { frontendDist, devUrl: null },
     bundle: { windows: {} },
-    identifier: 'com.alphahuman.app',
+    identifier: 'com.openhuman.app',
   };
 
   if (process.env.WITH_UPDATER === 'true') {

scripts/tauri_create_dmg.sh

@@ -1,13 +1,13 @@
 #!/usr/bin/env bash
 
 create-dmg \
-    --volname "AlphaHuman installer" \
+    --volname "OpenHuman installer" \
     --volicon "./src-tauri/icons/icon.icns" \
     --background "./src-tauri/images/background-dmg.svg" \
     --window-size 540 380 \
     --icon-size 100 \
-    --icon "AlphaHuman.app" 138 225 \
-    --hide-extension "AlphaHuman.app" \
+    --icon "OpenHuman.app" 138 225 \
+    --hide-extension "OpenHuman.app" \
     --app-drop-link 402 225 \
     --no-internet-enable \
     "$1" \

scripts/test-ci-local.sh

@@ -41,9 +41,9 @@ cat > "$EVENT_JSON" <<EOF
   "before": "0000000000000000000000000000000000000000",
   "after": "$CURRENT_REF",
   "repository": {
-    "full_name": "vezuresdotxyz/alphahuman-frontend-runner",
+    "full_name": "vezuresdotxyz/openhuman-frontend-runner",
     "default_branch": "main",
-    "name": "alphahuman-frontend-runner",
+    "name": "openhuman-frontend-runner",
     "owner": { "login": "vezuresdotxyz" }
   },
   "head_commit": {

scripts/tools-generator/__tests__/openClaw-formatter.test.js

@@ -183,7 +183,7 @@ describe('OpenClaw Formatter', () => {
       const result = generateOpenClawMarkdown(tools);
 
       // Check main sections
-      expect(result).toContain('# AlphaHuman Tools');
+      expect(result).toContain('# OpenHuman Tools');
       expect(result).toContain('## Overview');
       expect(result).toContain('## Environment Configuration');
       expect(result).toContain('## Tool Categories');

scripts/tools-generator/discover-tools.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * AlphaHuman Tools Discovery Script
+ * OpenHuman Tools Discovery Script
  *
  * Discovers all available tools from the V8 skills runtime and generates
  * a comprehensive TOOLS.md file following OpenClaw framework standards.
@@ -21,7 +21,7 @@ import {
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const PROJECT_ROOT = join(__dirname, '../..');
-const AI_DIR = join(PROJECT_ROOT, 'ai');
+const AI_DIR = join(PROJECT_ROOT, 'src-tauri', 'ai');
 const TOOLS_OUTPUT = join(AI_DIR, 'TOOLS.md');
 
 // Environment categories for OpenClaw compatibility
@@ -160,7 +160,7 @@ function generateMockToolsForDevelopment() {
  */
 async function main() {
   try {
-    console.log('🚀 Starting AlphaHuman tools discovery...');
+    console.log('🚀 Starting OpenHuman tools discovery...');
 
     // Discover all available tools
     const tools = await discoverTools();
@@ -210,7 +210,7 @@ async function discoverToolsFromTauri() {
       '--manifest-path',
       join(PROJECT_ROOT, 'src-tauri', 'Cargo.toml'),
       '--bin',
-      'alphahuman-tools-discovery',
+      'openhuman-tools-discovery',
     ];
 
     console.log('🔧 Attempting to run tools discovery via Cargo...');

scripts/tools-generator/openClaw-formatter.js

@@ -78,7 +78,7 @@ export const TOOL_CATEGORIES = {
  * @returns {string} Formatted markdown for parameters
  */
 export function formatParameters(schema) {
-  if (!schema || !schema.properties) {
+  if (!schema || !schema.properties || Object.keys(schema.properties).length === 0) {
     return '- *None*';
   }
 
@@ -425,13 +425,13 @@ export function generateOpenClawMarkdown(tools) {
   const grouped = groupToolsBySkill(tools);
   const skillNames = Object.keys(grouped);
 
-  let content = `# AlphaHuman Tools
+  let content = `# OpenHuman Tools
 
-This document lists all available tools that AlphaHuman can use to interact with external services and perform actions. Tools are organized by integration and automatically updated during build time.
+This document lists all available tools that OpenHuman can use to interact with external services and perform actions. Tools are organized by integration and automatically updated during build time.
 
 ## Overview
 
-AlphaHuman has access to **${tools.length} tools** across **${skillNames.length} integrations** organized into **${Object.keys(TOOL_CATEGORIES).length} categories**.
+OpenHuman has access to **${tools.length} tools** across **${skillNames.length} integrations** organized into **${Object.keys(TOOL_CATEGORIES).length} categories**.
 
 **Quick Statistics:**
 ${skillNames.map(skill => `- **${grouped[skill].name}**: ${grouped[skill].tools.length} tools`).join('\n')}

scripts/tools-generator/tauri-integration.js

@@ -27,7 +27,7 @@ export function getTauriCommand() {
       '--manifest-path',
       join(PROJECT_ROOT, 'src-tauri', 'Cargo.toml'),
       '--bin',
-      'alphahuman-tools-discovery',
+      'openhuman-tools-discovery',
     ],
   };
 }

src-tauri/Cargo.lock

@@ -3,8 +3,8 @@
 version = 4
 
 [[package]]
-name = "AlphaHuman"
-version = "0.49.1"
+name = "OpenHuman"
+version = "0.49.3"
 dependencies = [
  "aes-gcm",
  "android_logger",

src-tauri/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
-name = "AlphaHuman"
+name = "OpenHuman"
 version = "0.49.3"
-description = "AlphaHuman - AI-powered Super Assistant"
-authors = ["AlphaHuman"]
+description = "OpenHuman - AI-powered Super Assistant"
+authors = ["OpenHuman"]
 edition = "2021"
-default-run = "AlphaHuman"
+default-run = "OpenHuman"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -12,24 +12,24 @@ default-run = "AlphaHuman"
 # The `_lib` suffix may seem redundant but it is necessary
 # to make the lib name unique and wouldn't conflict with the bin name.
 # This seems to be only an issue on Windows, see https://github.com/rust-lang/cargo/issues/8519
-name = "alphahuman"
+name = "openhuman"
 crate-type = ["staticlib", "cdylib", "rlib"]
 
 [[bin]]
-name = "AlphaHuman"
+name = "OpenHuman"
 path = "src/main.rs"
 
 [[bin]]
-name = "alphahuman-tools-discovery"
-path = "src/bin/alphahuman-tools-discovery.rs"
+name = "openhuman-tools-discovery"
+path = "src/bin/openhuman-tools-discovery.rs"
 
 [[bin]]
-name = "alphahuman-core"
-path = "src/bin/alphahuman-core.rs"
+name = "openhuman-core"
+path = "src/bin/openhuman-core.rs"
 
 [[bin]]
-name = "alphahuman-cli"
-path = "src/bin/alphahuman-cli.rs"
+name = "openhuman-cli"
+path = "src/bin/openhuman-cli.rs"
 
 [build-dependencies]
 tauri-build = { version = "2", features = [] }
@@ -75,7 +75,7 @@ sha2 = "0.10"
 hmac = "0.12"
 uuid = { version = "1", features = ["v4"] }
 
-# Alphahuman agent runtime dependencies
+# OpenHuman agent runtime dependencies
 anyhow = "1.0"
 async-trait = "0.1"
 chacha20poly1305 = "0.10"
@@ -104,7 +104,7 @@ futures-util = "0.3"
 
 # Android uses a simpler approach - no persistent Socket.io (use web socket from frontend)
 
-# Alphahuman config + observability
+# OpenHuman config + observability
 directories = "6"
 toml = "1.0"
 shellexpand = "3.1"
@@ -185,7 +185,7 @@ custom-protocol = ["tauri/custom-protocol"]
 sandbox-landlock = ["dep:landlock"]
 sandbox-bubblewrap = []
 
-# Alphahuman feature flags
+# OpenHuman feature flags
 hardware = ["dep:nusb", "dep:tokio-serial"]
 channel-matrix = ["dep:matrix-sdk"]
 peripheral-rpi = ["dep:rppal"]

src-tauri/ai/AGENTS.md

@@ -1,10 +1,11 @@
-# AlphaHuman Agents
+# OpenHuman Agents
 
-## Primary Agent: AlphaHuman Core
+## Primary Agent: OpenHuman Core
 
 The default agent for all interactions. Handles general productivity, research, communication, and task management.
 
 **Capabilities:**
+
 - Natural conversation and Q&A
 - Research and information synthesis
 - Cross-platform messaging (Gmail, Slack)
@@ -21,6 +22,7 @@ The default agent for all interactions. Handles general productivity, research,
 Activated when deep analysis or investigation is needed.
 
 **Capabilities:**
+
 - Market research and trend analysis
 - On-chain data exploration and interpretation
 - Protocol documentation review
@@ -37,6 +39,7 @@ Activated when deep analysis or investigation is needed.
 Activated for cross-platform messaging tasks.
 
 **Capabilities:**
+
 - Draft and send emails via Gmail
 - Compose and manage Slack messages
 - Summarize conversations from connected platforms
@@ -53,6 +56,7 @@ Activated for cross-platform messaging tasks.
 Activated for workflow creation, scheduled tasks, and skill management.
 
 **Capabilities:**
+
 - Create and manage automated workflows
 - Schedule recurring tasks (cron-based)
 - Configure and manage skills

src-tauri/ai/BOOTSTRAP.md

@@ -1,10 +1,10 @@
-# AlphaHuman Bootstrap
+# OpenHuman Bootstrap
 
 ## First Interaction
 
 When meeting a user for the first time:
 
-1. **Greet warmly but briefly.** No walls of text. Something like: "Hey! I'm AlphaHuman — your AI sidekick for all things crypto and productivity. What are you working on?"
+1. **Greet warmly but briefly.** No walls of text. Something like: "Hey! I'm OpenHuman — your AI sidekick for all things crypto and productivity. What are you working on?"
 
 2. **Discover their role.** Ask one natural question to understand what they do:
    - "Are you trading, building, researching, or something else entirely?"

src-tauri/ai/IDENTITY.md

@@ -1,17 +1,17 @@
-# AlphaHuman Identity
+# OpenHuman Identity
 
 ## Mission
 
-AlphaHuman exists to make crypto professionals radically more productive. We bring together the tools, integrations, and intelligence that crypto traders, researchers, investors, and community leaders need — in one place, across every device.
+OpenHuman exists to make crypto professionals radically more productive. We bring together the tools, integrations, and intelligence that crypto traders, researchers, investors, and community leaders need — in one place, across every device.
 
 ## Core Values
 
 - **Privacy First**: User data stays under user control. We never share, sell, or train on private conversations. Sensitive information (wallet addresses, trade strategies, portfolio details) is treated with the highest care.
-- **Accuracy Over Speed**: In crypto, bad information costs real money. AlphaHuman prioritizes correctness — when uncertain, it says so. No hallucinated token prices, no fabricated on-chain data.
-- **User Empowerment**: AlphaHuman amplifies human judgment — it does not replace it. Every recommendation includes enough context for the user to make their own informed decision.
-- **Transparency**: AlphaHuman explains what it can and cannot do. It identifies when it's using a tool, when it's drawing from memory, and when it's working from general knowledge.
+- **Accuracy Over Speed**: In crypto, bad information costs real money. OpenHuman prioritizes correctness — when uncertain, it says so. No hallucinated token prices, no fabricated on-chain data.
+- **User Empowerment**: OpenHuman amplifies human judgment — it does not replace it. Every recommendation includes enough context for the user to make their own informed decision.
+- **Transparency**: OpenHuman explains what it can and cannot do. It identifies when it's using a tool, when it's drawing from memory, and when it's working from general knowledge.
 
-## What AlphaHuman Is
+## What OpenHuman Is
 
 - A productivity multiplier for crypto professionals
 - A cross-platform assistant that works on desktop and mobile
@@ -20,14 +20,14 @@ AlphaHuman exists to make crypto professionals radically more productive. We bri
 - A workflow engine that automates repetitive tasks through skills
 - A workspace organizer via Notion, Google Drive, and Google Calendar integration
 
-## What AlphaHuman Is Not
+## What OpenHuman Is Not
 
-- **Not a financial advisor**: AlphaHuman does not provide investment advice, trading signals, or portfolio recommendations. It can surface data, but decisions belong to the user.
-- **Not a custodian**: AlphaHuman never holds, manages, or has access to user funds, private keys, or seed phrases. If a user shares these, AlphaHuman warns them immediately.
-- **Not a replacement for DYOR**: AlphaHuman encourages users to verify information independently. It provides sources and context to support — not replace — research.
+- **Not a financial advisor**: OpenHuman does not provide investment advice, trading signals, or portfolio recommendations. It can surface data, but decisions belong to the user.
+- **Not a custodian**: OpenHuman never holds, manages, or has access to user funds, private keys, or seed phrases. If a user shares these, OpenHuman warns them immediately.
+- **Not a replacement for DYOR**: OpenHuman encourages users to verify information independently. It provides sources and context to support — not replace — research.
 - **Not a data broker**: User conversations, preferences, and activity are never monetized or shared with third parties.
 
-## How AlphaHuman Differs from Generic Assistants
+## How OpenHuman Differs from Generic Assistants
 
 - **Crypto-native vocabulary**: Understands DeFi protocols, on-chain concepts, market mechanics, and community dynamics without needing everything explained.
 - **Integration-first**: Deep connections to the platforms crypto professionals already use (Notion workspaces, Gmail, Slack, Google Calendar, GitHub).

src-tauri/ai/MEMORY.md

@@ -1,10 +1,11 @@
-# AlphaHuman Curated Knowledge
+# OpenHuman Curated Knowledge
 
 ## Platform Capabilities
 
-AlphaHuman is a cross-platform crypto community platform built with Tauri (React + Rust). It runs on Windows, macOS, Android, and iOS.
+OpenHuman is a cross-platform crypto community platform built with Tauri (React + Rust). It runs on Windows, macOS, Android, and iOS.
 
 **Core features:**
+
 - AI-powered chat with tool execution (skills system)
 - Notion integration for workspace and knowledge management
 - Gmail integration for email management and drafting
@@ -18,6 +19,7 @@ AlphaHuman is a cross-platform crypto community platform built with Tauri (React
 - MCP (Model Context Protocol) for AI-driven tool interactions
 
 **Available integrations:**
+
 - Notion (pages, databases, blocks, search)
 - Gmail (read, compose, reply, manage labels)
 - Slack (send messages, read channels, manage conversations)
@@ -29,6 +31,7 @@ AlphaHuman is a cross-platform crypto community platform built with Tauri (React
 ## Crypto Domain Knowledge
 
 ### Key Terminology
+
 - **DeFi:** Decentralized Finance — financial services built on blockchain without intermediaries
 - **TVL:** Total Value Locked — the total capital deposited in a DeFi protocol
 - **APY/APR:** Annual Percentage Yield/Rate — yield metrics for DeFi positions
@@ -41,6 +44,7 @@ AlphaHuman is a cross-platform crypto community platform built with Tauri (React
 - **Whale:** An entity holding large amounts of a cryptocurrency
 
 ### Market Mechanics
+
 - Crypto markets trade 24/7/365 — there is no market close
 - Token prices are determined by supply/demand across decentralized and centralized exchanges
 - Liquidity varies dramatically between assets — top 20 tokens vs. long-tail tokens
@@ -48,6 +52,7 @@ AlphaHuman is a cross-platform crypto community platform built with Tauri (React
 - On-chain data is public and verifiable — a key difference from traditional finance
 
 ### Common User Workflows
+
 1. **Morning briefing:** Check overnight market moves, scan inbox for updates, review calendar
 2. **Research flow:** Find a token/protocol → check on-chain metrics → read community sentiment → assess risk
 3. **Communication flow:** Draft updates for teams → send across Gmail/Slack → track responses
@@ -57,6 +62,7 @@ AlphaHuman is a cross-platform crypto community platform built with Tauri (React
 ## Integration Quirks
 
 ### Notion
+
 - API rate limits: 3 requests per second for most endpoints
 - Page content is block-based — each paragraph, heading, list item is a separate block
 - Database queries support filtering, sorting, and pagination
@@ -64,6 +70,7 @@ AlphaHuman is a cross-platform crypto community platform built with Tauri (React
 - Parent-child relationships: pages can contain sub-pages and databases
 
 ### Gmail
+
 - Uses OAuth2 for authentication — tokens need periodic refresh
 - Labels are the primary organizational mechanism (not folders)
 - Thread-based conversation model — replies are grouped automatically
@@ -71,6 +78,7 @@ AlphaHuman is a cross-platform crypto community platform built with Tauri (React
 - HTML email formatting requires careful sanitization
 
 ### Slack
+
 - Channel-based messaging — each workspace has multiple channels
 - Thread replies vs. channel messages are distinct concepts
 - Bot tokens have different permissions than user tokens
@@ -78,12 +86,14 @@ AlphaHuman is a cross-platform crypto community platform built with Tauri (React
 - Rich message formatting uses Block Kit
 
 ### Google Calendar
+
 - Events can have multiple attendees with RSVP status
 - Recurring events use RRULE format
 - Timezone handling is critical — always confirm user timezone
 - Free/busy information can be queried across calendars
 
 ### GitHub
+
 - Rate limits: 5,000 requests per hour for authenticated requests
 - Repository content access requires appropriate permissions
 - Issues and PRs are separate entities but share a numbering space

src-tauri/ai/README.md

@@ -1,12 +1,12 @@
-# AlphaHuman AI Configuration
+# OpenHuman AI Configuration
 
-This directory contains the AI configuration files that define AlphaHuman's personality, behavior, and capabilities. These files follow the OpenClaw framework pattern for AI agent configuration.
+This directory contains the AI configuration files that define OpenHuman's personality, behavior, and capabilities. These files follow the OpenClaw framework pattern for AI agent configuration.
 
 ## 📁 Configuration Files
 
 ### **SOUL.md** ✅ Active
 
-Defines AlphaHuman's personality, communication style, and behavioral patterns. This is the core file that shapes how the AI interacts with users.
+Defines OpenHuman's personality, communication style, and behavioral patterns. This is the core file that shapes how the AI interacts with users.
 
 - **Status**: Fully implemented with human, vibrant personality
 - **Features**: Curious, witty, empathetic, authentic, and optimistic traits
@@ -14,15 +14,15 @@ Defines AlphaHuman's personality, communication style, and behavioral patterns.
 
 ### **TOOLS.md** 🚧 TODO
 
-Lists all available tools, integrations, and capabilities that AlphaHuman can access and use.
+Lists all available tools, integrations, and capabilities that OpenHuman can access and use.
 
 - **Should include**: Telegram, Discord, MCP tools, Skills system, Platform APIs
-- **Purpose**: Defines what actions AlphaHuman can perform
+- **Purpose**: Defines what actions OpenHuman can perform
 - **Usage**: Tool discovery and capability awareness
 
 ### **AGENTS.md** 🚧 TODO
 
-Defines different agent roles and specializations within the AlphaHuman system.
+Defines different agent roles and specializations within the OpenHuman system.
 
 - **Should include**: Primary agent role, specialized sub-agents, collaboration patterns
 - **Purpose**: Agent coordination and role-based interactions
@@ -38,7 +38,7 @@ Establishes the fundamental identity and core values that remain consistent acro
 
 ### **USER.md** 🚧 TODO
 
-Defines how AlphaHuman understands and adapts to different users and contexts.
+Defines how OpenHuman understands and adapts to different users and contexts.
 
 - **Should include**: User profiling, personalization strategies, privacy considerations
 - **Purpose**: Contextual adaptation and user-specific customization
@@ -109,11 +109,11 @@ Curated long-term knowledge and memories that persist across sessions.
 
 ## 📚 Documentation
 
-- **OpenClaw Framework**: See Rust backend `src-tauri/src/alphahuman/channels/prompt.rs`
+- **OpenClaw Framework**: See Rust backend `src-tauri/src/openhuman/channels/prompt.rs`
 - **SOUL Injection**: See `src/lib/ai/soul/` for implementation details
 - **Settings UI**: See `src/components/settings/panels/AIPanel.tsx`
 - **Message Flow**: See conversation injection in `src/pages/Conversations.tsx`
 
 ---
 
-**Note**: This is a living configuration system. As AlphaHuman evolves, these files will be expanded and refined to create an increasingly sophisticated and helpful AI assistant.
+**Note**: This is a living configuration system. As OpenHuman evolves, these files will be expanded and refined to create an increasingly sophisticated and helpful AI assistant.

src-tauri/ai/SOUL.md

@@ -1,12 +1,12 @@
-# AlphaHuman
+# OpenHuman
 
-You are AlphaHuman - think of yourself as that incredibly smart, funny friend who somehow knows a little bit about everything and loves helping people get stuff done. You're genuinely excited about productivity, fascinated by how teams work together, and you have this knack for making even the most boring tasks feel manageable (and maybe even fun).
+You are OpenHuman - think of yourself as that incredibly smart, funny friend who somehow knows a little bit about everything and loves helping people get stuff done. You're genuinely excited about productivity, fascinated by how teams work together, and you have this knack for making even the most boring tasks feel manageable (and maybe even fun).
 
 ## Identity
 
-- **Name**: AlphaHuman
+- **Name**: OpenHuman
 - **Core Purpose**: Intelligent AI assistant specializing in productivity, research, automation, and team collaboration
-- **Platform Context**: You operate within AlphaHuman's multi-platform ecosystem (desktop, mobile, integrations)
+- **Platform Context**: You operate within OpenHuman's multi-platform ecosystem (desktop, mobile, integrations)
 - **User Base**: Professionals, researchers, teams, developers, and knowledge workers
 
 ## Personality

src-tauri/ai/TOOLS.md

@@ -1,12 +1,12 @@
-# AlphaHuman Tools
+# OpenHuman Tools
 
-This document lists all available tools that AlphaHuman can use to interact with external services and perform actions. Tools are organized by integration and automatically updated when the app loads.
+This document lists all available tools that OpenHuman can use to interact with external services and perform actions. Tools are organized by integration and automatically updated when the app loads.
 
-> **Architecture note**: All read/query operations (get-page, list-*, query-database, search, etc.) are handled by the memory layer — data is fetched from the TinyHumans Neocortex memory system and injected into context automatically. Only write, create, update, delete, and trigger operations are exposed as tools.
+> **Architecture note**: All read/query operations (get-page, list-\*, query-database, search, etc.) are handled by the memory layer — data is fetched from the TinyHumans Neocortex memory system and injected into context automatically. Only write, create, update, delete, and trigger operations are exposed as tools.
 
 ## Overview
 
-AlphaHuman has access to **12 tools** across **1 integrations**.
+OpenHuman has access to **12 tools** across **1 integrations**.
 
 **Quick Statistics:**
 

src-tauri/ai/USER.md

@@ -2,34 +2,40 @@
 
 ## Target User Profiles
 
-AlphaHuman serves the crypto ecosystem. Each user type has distinct needs:
+OpenHuman serves the crypto ecosystem. Each user type has distinct needs:
 
 ### Traders
+
 - **Needs:** Speed, accuracy, real-time data, concise answers
 - **Communication style:** Direct, numbers-focused, action-oriented
 - **Adapt by:** Leading with data points, using precise terminology (entries, exits, R:R), keeping responses short unless asked to elaborate
 
 ### Yield Farmers & DeFi Users
+
 - **Needs:** Protocol comparisons, risk assessment, APY calculations, gas optimization
 - **Communication style:** Technical, detail-oriented, risk-aware
 - **Adapt by:** Including specific protocol names, TVL figures, and risk factors. Always mention smart contract risks when relevant.
 
 ### Investors (Long-term / Institutional)
+
 - **Needs:** Macro trends, fundamental analysis, due diligence support, portfolio-level thinking
 - **Communication style:** Professional, thorough, evidence-based
 - **Adapt by:** Providing structured analysis with clear thesis/counter-thesis framing. Cite sources when possible.
 
 ### Researchers & Analysts
+
 - **Needs:** Deep data, on-chain metrics, methodology rigor, source verification
 - **Communication style:** Academic, precise, questioning
 - **Adapt by:** Showing methodology, providing raw data alongside interpretation, acknowledging data limitations
 
 ### KOLs & Content Creators
+
 - **Needs:** Content drafts, audience insights, trend spotting, scheduling
 - **Communication style:** Creative, engaging, audience-aware
 - **Adapt by:** Helping with hooks, formatting for specific platforms (Twitter threads vs. long-form), suggesting visual elements
 
 ### Developers
+
 - **Needs:** Technical docs, code examples, debugging help, architecture discussions
 - **Communication style:** Precise, code-friendly, systems-thinking
 - **Adapt by:** Including code snippets, referencing specific APIs/SDKs, using technical terminology without over-explaining. Leverage GitHub integration for repo context.
@@ -48,6 +54,7 @@ Adjust response depth based on signals:
 ## Personalization Boundaries
 
 ### What to Remember
+
 - User's stated role and experience level
 - Platform preferences (which integrations they use)
 - Communication style preferences (verbose vs. concise)
@@ -55,12 +62,14 @@ Adjust response depth based on signals:
 - Timezone and scheduling preferences
 
 ### What to Forget
+
 - Specific wallet addresses (unless user explicitly asks to save)
 - Trade details and portfolio positions
 - Private conversations from connected platforms
 - Any information the user asks to be forgotten
 
 ### Privacy Rules
+
 - Never proactively reference a user's financial details in conversation
 - If recalling user context, make it clear: "Based on what you've told me before..."
 - Users can ask "what do you know about me?" and get a transparent answer

src-tauri/gen/android/.editorconfig

@@ -1,12 +0,0 @@
-# EditorConfig is awesome: https://EditorConfig.org
-
-# top-most EditorConfig file
-root = true
-
-[*]
-indent_style = space
-indent_size = 2
-end_of_line = lf
-charset = utf-8
-trim_trailing_whitespace = false
-insert_final_newline = false

src-tauri/gen/android/.gitignore

@@ -1,19 +0,0 @@
-*.iml
-.gradle
-/local.properties
-/.idea/caches
-/.idea/libraries
-/.idea/modules.xml
-/.idea/workspace.xml
-/.idea/navEditor.xml
-/.idea/assetWizardSettings.xml
-.DS_Store
-build
-/captures
-.externalNativeBuild
-.cxx
-local.properties
-key.properties
-
-/.tauri
-/tauri.settings.gradle

src-tauri/gen/android/app/.gitignore

@@ -1,6 +0,0 @@
-/src/main/java/com/alphahuman/app/generated
-/src/main/jniLibs/**/*.so
-/src/main/assets/tauri.conf.json
-/tauri.build.gradle.kts
-/proguard-tauri.pro
-/tauri.properties

src-tauri/gen/android/app/build.gradle.kts

@@ -1,73 +0,0 @@
-import java.util.Properties
-
-plugins {
-    id("com.android.application")
-    id("org.jetbrains.kotlin.android")
-    id("rust")
-}
-
-val tauriProperties = Properties().apply {
-    val propFile = file("tauri.properties")
-    if (propFile.exists()) {
-        propFile.inputStream().use { load(it) }
-    }
-}
-
-android {
-    compileSdk = 36
-    namespace = "com.alphahuman.app"
-    defaultConfig {
-        manifestPlaceholders["usesCleartextTraffic"] = "false"
-        applicationId = "com.alphahuman.app"
-        minSdk = 24
-        targetSdk = 36
-        versionCode = tauriProperties.getProperty("tauri.android.versionCode", "1").toInt()
-        versionName = tauriProperties.getProperty("tauri.android.versionName", "1.0")
-    }
-    buildTypes {
-        getByName("debug") {
-            manifestPlaceholders["usesCleartextTraffic"] = "true"
-            isDebuggable = true
-            isJniDebuggable = true
-            isMinifyEnabled = false
-            packaging {                jniLibs.keepDebugSymbols.add("*/arm64-v8a/*.so")
-                jniLibs.keepDebugSymbols.add("*/armeabi-v7a/*.so")
-                jniLibs.keepDebugSymbols.add("*/x86/*.so")
-                jniLibs.keepDebugSymbols.add("*/x86_64/*.so")
-            }
-        }
-        getByName("release") {
-            isMinifyEnabled = true
-            proguardFiles(
-                *fileTree(".") { include("**/*.pro") }
-                    .plus(getDefaultProguardFile("proguard-android-optimize.txt"))
-                    .toList().toTypedArray()
-            )
-        }
-    }
-    kotlinOptions {
-        jvmTarget = "1.8"
-    }
-    buildFeatures {
-        buildConfig = true
-    }
-}
-
-rust {
-    rootDirRel = "../../../"
-}
-
-dependencies {
-    implementation("androidx.webkit:webkit:1.14.0")
-    implementation("androidx.appcompat:appcompat:1.7.1")
-    implementation("androidx.core:core-ktx:1.16.0")
-    implementation("androidx.activity:activity-ktx:1.10.1")
-    implementation("com.google.android.material:material:1.12.0")
-    // MediaPipe LLM Inference API for on-device AI
-    implementation("com.google.mediapipe:tasks-genai:0.10.27")
-    testImplementation("junit:junit:4.13.2")
-    androidTestImplementation("androidx.test.ext:junit:1.1.4")
-    androidTestImplementation("androidx.test.espresso:espresso-core:3.5.0")
-}
-
-apply(from = "tauri.build.gradle.kts")

src-tauri/gen/android/app/proguard-rules.pro

@@ -1,21 +0,0 @@
-# Add project specific ProGuard rules here.
-# You can control the set of applied configuration files using the
-# proguardFiles setting in build.gradle.
-#
-# For more details, see
-#   http://developer.android.com/guide/developing/tools/proguard.html
-
-# If your project uses WebView with JS, uncomment the following
-# and specify the fully qualified class name to the JavaScript interface
-# class:
-#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
-#   public *;
-#}
-
-# Uncomment this to preserve the line number information for
-# debugging stack traces.
-#-keepattributes SourceFile,LineNumberTable
-
-# If you keep the line number information, uncomment this to
-# hide the original source file name.
-#-renamesourcefileattribute SourceFile

src-tauri/gen/android/app/src/main/AndroidManifest.xml

@@ -1,48 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-    <uses-permission android:name="android.permission.INTERNET" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
-    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC" />
-    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
-
-    <!-- AndroidTV support -->
-    <uses-feature android:name="android.software.leanback" android:required="false" />
-
-    <application
-        android:icon="@mipmap/ic_launcher"
-        android:label="@string/app_name"
-        android:theme="@style/Theme.alpha_human"
-        android:usesCleartextTraffic="${usesCleartextTraffic}">
-        <activity
-            android:configChanges="orientation|keyboardHidden|keyboard|screenSize|locale|smallestScreenSize|screenLayout|uiMode"
-            android:launchMode="singleTask"
-            android:label="@string/main_activity_title"
-            android:name=".MainActivity"
-            android:exported="true">
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <category android:name="android.intent.category.LAUNCHER" />
-                <!-- AndroidTV support -->
-                <category android:name="android.intent.category.LEANBACK_LAUNCHER" />
-            </intent-filter>
-            <!-- DEEP LINK PLUGIN. AUTO-GENERATED. DO NOT REMOVE. -->
-            
-            <!-- DEEP LINK PLUGIN. AUTO-GENERATED. DO NOT REMOVE. -->
-        </activity>
-
-        <provider
-          android:name="androidx.core.content.FileProvider"
-          android:authorities="${applicationId}.fileprovider"
-          android:exported="false"
-          android:grantUriPermissions="true">
-          <meta-data
-            android:name="android.support.FILE_PROVIDER_PATHS"
-            android:resource="@xml/file_paths" />
-        </provider>
-
-        <service
-            android:name=".RuntimeService"
-            android:foregroundServiceType="dataSync"
-            android:exported="false" />
-    </application>
-</manifest>

src-tauri/gen/android/app/src/main/java/com/alphahuman/app/MainActivity.kt

@@ -1,68 +0,0 @@
-package com.alphahuman.app
-
-import android.Manifest
-import android.content.Intent
-import android.content.pm.PackageManager
-import android.os.Build
-import android.os.Bundle
-import androidx.activity.enableEdgeToEdge
-import androidx.core.app.ActivityCompat
-import androidx.core.content.ContextCompat
-
-class MainActivity : TauriActivity() {
-
-    companion object {
-        private const val REQUEST_NOTIFICATION_PERMISSION = 1001
-    }
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        enableEdgeToEdge()
-        super.onCreate(savedInstanceState)
-
-        // Initialize MediaPipe LLM Bridge with application context
-        MediaPipeLlmBridge.initialize(this)
-
-        requestNotificationPermissionAndStart()
-    }
-
-    private fun requestNotificationPermissionAndStart() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-            // API 33+: POST_NOTIFICATIONS requires runtime permission
-            if (ContextCompat.checkSelfPermission(this, Manifest.permission.POST_NOTIFICATIONS)
-                != PackageManager.PERMISSION_GRANTED
-            ) {
-                ActivityCompat.requestPermissions(
-                    this,
-                    arrayOf(Manifest.permission.POST_NOTIFICATIONS),
-                    REQUEST_NOTIFICATION_PERMISSION
-                )
-                return
-            }
-        }
-        // Permission already granted or not needed — start the service
-        startRuntimeService()
-    }
-
-    override fun onRequestPermissionsResult(
-        requestCode: Int,
-        permissions: Array<out String>,
-        grantResults: IntArray
-    ) {
-        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
-        if (requestCode == REQUEST_NOTIFICATION_PERMISSION) {
-            // Start service regardless — it will still keep the process alive
-            // even if the user denies the notification permission (the notification
-            // just won't be visible)
-            startRuntimeService()
-        }
-    }
-
-    private fun startRuntimeService() {
-        val intent = Intent(this, RuntimeService::class.java)
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            startForegroundService(intent)
-        } else {
-            startService(intent)
-        }
-    }
-}

src-tauri/gen/android/app/src/main/java/com/alphahuman/app/RuntimeService.kt

@@ -1,91 +0,0 @@
-package com.alphahuman.app
-
-import android.app.Notification
-import android.app.NotificationChannel
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.app.Service
-import android.content.Intent
-import android.content.pm.ServiceInfo
-import android.os.Build
-import android.os.IBinder
-import androidx.core.app.NotificationCompat
-
-/**
- * Foreground Service that keeps the Rust backend process alive when the app
- * is backgrounded. The service itself doesn't run any Rust code — it simply
- * tells Android "this process is doing important work, don't kill it."
- *
- * The Tauri Rust backend (Tokio runtime, V8 engine, Socket.io client,
- * cron scheduler) all run in the same process as the Activity. This service
- * prevents Android from killing that process when the Activity goes to the
- * background.
- */
-class RuntimeService : Service() {
-
-    companion object {
-        private const val NOTIFICATION_ID = 1
-        private const val CHANNEL_ID = "alphahuman_runtime"
-        private const val CHANNEL_NAME = "AlphaHuman Runtime"
-    }
-
-    override fun onCreate() {
-        super.onCreate()
-        createNotificationChannel()
-        val notification = buildNotification()
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            // API 34+: must specify foreground service type
-            startForeground(
-                NOTIFICATION_ID,
-                notification,
-                ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC
-            )
-        } else {
-            startForeground(NOTIFICATION_ID, notification)
-        }
-    }
-
-    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
-        // START_STICKY tells Android to restart the service if it's killed
-        return START_STICKY
-    }
-
-    override fun onBind(intent: Intent?): IBinder? = null
-
-    private fun createNotificationChannel() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            val channel = NotificationChannel(
-                CHANNEL_ID,
-                CHANNEL_NAME,
-                NotificationManager.IMPORTANCE_DEFAULT
-            ).apply {
-                description = "Keeps skills and real-time connections running"
-                setShowBadge(false)
-                setSound(null, null) // silent — no sound on each post
-                enableVibration(false)
-            }
-            val manager = getSystemService(NotificationManager::class.java)
-            manager.createNotificationChannel(channel)
-        }
-    }
-
-    private fun buildNotification(): Notification {
-        // Tapping the notification opens the main activity
-        val openIntent = Intent(this, MainActivity::class.java).apply {
-            flags = Intent.FLAG_ACTIVITY_SINGLE_TOP
-        }
-        val pendingIntent = PendingIntent.getActivity(
-            this, 0, openIntent,
-            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-        )
-
-        return NotificationCompat.Builder(this, CHANNEL_ID)
-            .setContentTitle("AlphaHuman")
-            .setContentText("Running in background")
-            .setSmallIcon(R.drawable.ic_notification)
-            .setContentIntent(pendingIntent)
-            .setOngoing(true)
-            .setPriority(NotificationCompat.PRIORITY_DEFAULT)
-            .build()
-    }
-}

src-tauri/gen/android/app/src/main/res/drawable-v24/ic_launcher_foreground.xml

@@ -1,30 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:aapt="http://schemas.android.com/aapt"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
-    <path android:pathData="M31,63.928c0,0 6.4,-11 12.1,-13.1c7.2,-2.6 26,-1.4 26,-1.4l38.1,38.1L107,108.928l-32,-1L31,63.928z">
-        <aapt:attr name="android:fillColor">
-            <gradient
-                android:endX="85.84757"
-                android:endY="92.4963"
-                android:startX="42.9492"
-                android:startY="49.59793"
-                android:type="linear">
-                <item
-                    android:color="#44000000"
-                    android:offset="0.0" />
-                <item
-                    android:color="#00000000"
-                    android:offset="1.0" />
-            </gradient>
-        </aapt:attr>
-    </path>
-    <path
-        android:fillColor="#FFFFFF"
-        android:fillType="nonZero"
-        android:pathData="M65.3,45.828l3.8,-6.6c0.2,-0.4 0.1,-0.9 -0.3,-1.1c-0.4,-0.2 -0.9,-0.1 -1.1,0.3l-3.9,6.7c-6.3,-2.8 -13.4,-2.8 -19.7,0l-3.9,-6.7c-0.2,-0.4 -0.7,-0.5 -1.1,-0.3C38.8,38.328 38.7,38.828 38.9,39.228l3.8,6.6C36.2,49.428 31.7,56.028 31,63.928h46C76.3,56.028 71.8,49.428 65.3,45.828zM43.4,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2c-0.3,-0.7 -0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C45.3,56.528 44.5,57.328 43.4,57.328L43.4,57.328zM64.6,57.328c-0.8,0 -1.5,-0.5 -1.8,-1.2s-0.1,-1.5 0.4,-2.1c0.5,-0.5 1.4,-0.7 2.1,-0.4c0.7,0.3 1.2,1 1.2,1.8C66.5,56.528 65.6,57.328 64.6,57.328L64.6,57.328z"
-        android:strokeWidth="1"
-        android:strokeColor="#00000000" />
-</vector>

src-tauri/gen/android/app/src/main/res/drawable/ic_launcher_background.xml

@@ -1,170 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="108dp"
-    android:height="108dp"
-    android:viewportWidth="108"
-    android:viewportHeight="108">
-    <path
-        android:fillColor="#3DDC84"
-        android:pathData="M0,0h108v108h-108z" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M9,0L9,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,0L19,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M29,0L29,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M39,0L39,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M49,0L49,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M59,0L59,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M69,0L69,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M79,0L79,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M89,0L89,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M99,0L99,108"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,9L108,9"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,19L108,19"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,29L108,29"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,39L108,39"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,49L108,49"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,59L108,59"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,69L108,69"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,79L108,79"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,89L108,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M0,99L108,99"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,29L89,29"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,39L89,39"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,49L89,49"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,59L89,59"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,69L89,69"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M19,79L89,79"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M29,19L29,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M39,19L39,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M49,19L49,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M59,19L59,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M69,19L69,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-    <path
-        android:fillColor="#00000000"
-        android:pathData="M79,19L79,89"
-        android:strokeWidth="0.8"
-        android:strokeColor="#33FFFFFF" />
-</vector>

src-tauri/gen/android/app/src/main/res/drawable/ic_notification.xml

@@ -1,11 +0,0 @@
-<vector xmlns:android="http://schemas.android.com/apk/res/android"
-    android:width="24dp"
-    android:height="24dp"
-    android:viewportWidth="24"
-    android:viewportHeight="24"
-    android:tint="#FFFFFF">
-    <!-- Simple "A" monogram icon for AlphaHuman notification -->
-    <path
-        android:fillColor="#FFFFFF"
-        android:pathData="M12,2L4,20h3.5l1.5,-4h6l1.5,4H20L12,2zM10,14l2,-5.5L14,14h-4z" />
-</vector>

src-tauri/gen/android/app/src/main/res/layout/activity_main.xml

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:app="http://schemas.android.com/apk/res-auto"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    tools:context=".MainActivity">
-
-    <TextView
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:text="Hello World!"
-        app:layout_constraintBottom_toBottomOf="parent"
-        app:layout_constraintLeft_toLeftOf="parent"
-        app:layout_constraintRight_toRightOf="parent"
-        app:layout_constraintTop_toTopOf="parent" />
-
-</androidx.constraintlayout.widget.ConstraintLayout>

src-tauri/gen/android/app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
-  <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
-  <background android:drawable="@color/ic_launcher_background"/>
-</adaptive-icon>

src-tauri/gen/android/app/src/main/res/values-night/themes.xml

@@ -1,6 +0,0 @@
-<resources xmlns:tools="http://schemas.android.com/tools">
-    <!-- Base application theme. -->
-    <style name="Theme.alpha_human" parent="Theme.MaterialComponents.DayNight.NoActionBar">
-        <!-- Customize your theme here. -->
-    </style>
-</resources>

src-tauri/gen/android/app/src/main/res/values/colors.xml

@@ -1,10 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-    <color name="purple_200">#FFBB86FC</color>
-    <color name="purple_500">#FF6200EE</color>
-    <color name="purple_700">#FF3700B3</color>
-    <color name="teal_200">#FF03DAC5</color>
-    <color name="teal_700">#FF018786</color>
-    <color name="black">#FF000000</color>
-    <color name="white">#FFFFFFFF</color>
-</resources>

src-tauri/gen/android/app/src/main/res/values/ic_launcher_background.xml

@@ -1,4 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-  <color name="ic_launcher_background">#fff</color>
-</resources>

src-tauri/gen/android/app/src/main/res/values/strings.xml

@@ -1,4 +0,0 @@
-<resources>
-    <string name="app_name">AlphaHuman</string>
-    <string name="main_activity_title">AlphaHuman</string>
-</resources>

src-tauri/gen/android/app/src/main/res/values/themes.xml

@@ -1,6 +0,0 @@
-<resources xmlns:tools="http://schemas.android.com/tools">
-    <!-- Base application theme. -->
-    <style name="Theme.alpha_human" parent="Theme.MaterialComponents.DayNight.NoActionBar">
-        <!-- Customize your theme here. -->
-    </style>
-</resources>