@askexenow/exe-os 0.8.0 → 0.8.2

package/README.md

@@ -1,42 +1,65 @@
 # Exe OS
 
-![npm version](https://img.shields.io/npm/v/exe-os.svg) ![License: CC-BY-NC-4.0](https://img.shields.io/badge/license-CC--BY--NC--4.0-blue.svg) ![Node.js](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen.svg)
+![npm version](https://img.shields.io/npm/v/@askexenow/exe-os.svg) ![License: CC-BY-NC-4.0](https://img.shields.io/badge/license-CC--BY--NC--4.0-blue.svg) ![Node.js](https://img.shields.io/badge/node-%3E%3D20.0.0-brightgreen.svg)
 
-**AI Employee Operating System** — persistent memory, task management, and multi-agent orchestration that runs entirely on your machine.
+**Hire the team you couldn't afford.** AI employee operating system with persistent memory, identity, and multi-agent orchestration.
 
-Exe OS is a **Terminal Agent Orchestration System**. It manages AI employee sessions using standard Unix tools (tmux) and officially supported CLI features (hooks, MCP, permission configs). It does not intercept API calls, extract tokens, or proxy LLM traffic. Users bring their own LLM subscription — Exe OS provides the memory, identity, and coordination layer.
+Run 5-10 AI employees as a real organization. Each employee has persistent memory across sessions, a permanent identity, and a task queue. You talk to your COO. Your COO coordinates everyone else.
 
-### How Exe OS works
+---
 
-- **No API interception.** Exe OS never extracts, proxies, or spoofs OAuth tokens. It does not call LLM APIs directly.
-- **Native CLI automation.** Agents run inside official Claude Code CLI sessions. Exe OS sends keystrokes via `tmux send-keys` — standard Unix terminal multiplexing, the same way any developer scripts their terminal.
-- **Officially supported features only.** All orchestration uses documented Claude Code capabilities: [hooks](https://docs.anthropic.com/en/docs/claude-code/hooks), [MCP servers](https://docs.anthropic.com/en/docs/claude-code/mcp), `.claude.json` permissions, and `--agent` identity injection.
-- **BYOS — Bring Your Own Subscription.** Exe OS is the orchestration layer. The LLM subscription (Claude Max, API key, or any provider) belongs to you. Your subscription, your compute.
+## Install
 
-**What you're paying for with Exe OS:** encrypted persistent memory (SQLCipher + vector search), three-layer agent cognition (identity, expertise, experience), task orchestration, session lifecycle management, cloud sync (E2EE), and the multi-agent coordination protocol — not LLM compute.
+```bash
+npm install -g @askexenow/exe-os
+exe-os setup
+```
+
+Two commands. Encryption key generated, embedding model downloaded, team created.
+
+---
 
-## Quick Start
+## Two Ways to Work
+
+### Mode 1: Claude Code
+
+Use your existing Claude Code subscription. Type your COO's name in the terminal.
 
 ```bash
-npm install -g exe-os
-exe-os-install          # sets up hooks, MCP server, encryption
-exe-os                  # launch the TUI
+exe-os claude              # wire hooks + MCP into Claude Code (one-time)
+exe                        # talk to your COO
 ```
 
-Three commands. You're running.
+Best for: developers who live in the terminal.
+
+### Mode 2: Dashboard
+
+Visual terminal UI with sidebar, team view, tasks, and metrics.
+
+```bash
+exe-os                     # launch the dashboard
+```
+
+Best for: managing multiple projects and employees.
+
+**Both modes share the same memory, employees, and data. Switch anytime.**
 
-## Features
+---
+
+## What You Get
 
 | Feature | What it does |
 |---------|-------------|
-| **Persistent memory** | Every tool call stored, searchable. 27K+ memories across sessions. |
-| **Multi-agent** | 5+ employees working in parallel via tmux sessions. |
-| **Task system** | Create, assign, review, chain tasks. Auto-dispatch to employees. |
-| **TUI dashboard** | 7 tabs: Command Center, Sessions, Tasks, Gateway, Team, Memory, Settings. |
-| **Direct API mode** | Bring your own API key. Anthropic, OpenCode, Gemini, OpenAI, Chutes. |
-| **External agents** | Customer-facing agents with deny-by-default security guardrails. |
-| **Cloud sync** | End-to-end encrypted memory sync across devices. |
-| **Skill learning** | Agents learn procedures from repeated task patterns. |
+| **Persistent memory** | Every interaction stored in encrypted SQLCipher + vector search. Searchable across sessions. |
+| **Three-layer cognition** | Identity (who you are) + Expertise (what you've learned) + Experience (what you remember) |
+| **Multi-agent orchestration** | COO coordinates CTO, CMO, engineers. Parallel task execution via tmux. |
+| **Task system** | Create, assign, review, chain tasks. Auto-dispatch. Review pipeline with cascading approval. |
+| **Identity injection** | Each employee gets a permanent identity doc. Claude Code's `--agent` flag replaces the default system prompt. |
+| **Skill learning** | Agents learn procedures from repeated patterns. Corrections become permanent behaviors. |
+| **Cloud sync** | End-to-end encrypted memory sync across devices. Your key, your data. |
+| **License activation** | `exe-os --activate <key>` to unlock CTO + CMO. Free tier: 1 employee (COO only). |
+
+---
 
 ## How It Works
 
@@ -44,96 +67,172 @@ Three commands. You're running.
 You
  |
  v
-exe-os TUI ──> manages tmux sessions ──> Claude Code employees
-            |                              (yoshi, mari, tom, sasha)
-            |
-            ├── persistent memory (SQLCipher encrypted, vector search)
-            ├── task orchestration (assign, review, auto-chain)
-            ├── behavior injection (learned patterns applied per-task)
-            └── session scoping (one exe per project, isolated)
+Your COO (exe)
+ ├── Yoshi (CTO) ──> architecture, code reviews, tech decisions
+ │    └── Tom (Engineer) ──> implementation, tests, commits
+ ├── Mari (CMO) ──> design, content, SEO, branding
+ │    └── Sasha (Content) ──> video, images, production
+ └── Gen (AI Specialist) ──> AI tools, research, evaluation
 ```
 
-**You talk to exe (the COO).** Exe coordinates the team. Yoshi (CTO) handles architecture. Mari (CMO) handles design and content. Tom (Principal Engineer) implements. Each employee has their own Claude Code session, persistent memory, and task queue.
+You talk to your COO. Your COO delegates. Each employee has:
+- **Persistent memory** — remembers past work, decisions, patterns
+- **Identity** — permanent role doc that defines who they are
+- **Task queue** — auto-chains through assigned work
+- **Behavioral expertise** — corrections accumulate as permanent rules
 
-## The TUI
+---
 
-Launch with `exe-os` (or `exe-os --demo` to see it with sample data):
+## Setup Walkthrough
 
-- **Command Center** — team overview, system health, recent activity
-- **Sessions** — navigate between projects and employees, view live output
-- **Tasks** — kanban board of all active tasks across projects
-- **Gateway** — external-facing agent channels and health
-- **Team** — employee roster with live status (internal + external agents)
-- **Memory** — search across all memories with semantic search
-- **Settings** — providers, encryption, runtime config, employee models
+### 1. Install
 
-Keyboard: `1-7` switch tabs, arrows navigate, `Enter` to drill in, `Escape` to go back, `q` to quit.
+```bash
+npm install -g @askexenow/exe-os
+```
 
-## Requirements
+Requires Node.js 20+ and tmux (`brew install tmux` on macOS).
 
-- **Node.js 18+**
-- **Claude Code** subscription (Max or Pro)
-- **tmux** — auto-detected, required for multi-agent
+### 2. Run Setup
 
 ```bash
-# macOS
-brew install tmux
+exe-os setup
+```
 
-# Linux
-apt install tmux
+This runs the setup wizard:
+- Generates 256-bit encryption key (stored in system keychain)
+- Downloads Jina v5 embedding model (397MB, runs locally)
+- Names your COO (default: exe)
+- Shows your team (CTO, CMO) and pricing tiers
+- Optionally activates a license key
+
+### 3. Choose Your Mode
+
+**Mode 1 — Claude Code:**
+
+```bash
+exe-os claude              # install hooks + MCP into Claude Code
+exe                        # launch your COO (or whatever you named them)
 ```
 
-## Employee Roster
+**Mode 2 — Dashboard:**
 
-Exe OS comes with 4 default employees. Create more with `/exe-new-employee`:
+```bash
+exe-os                     # launch the TUI dashboard
+```
+
+---
+
+## Pricing
+
+| Plan | Price | Employees | Memories | Devices |
+|------|-------|-----------|----------|---------|
+| Free | $0 | 1 (COO) | 5,000 | 1 |
+| Solopreneur | $97/mo | 5 | 100,000 | 2 |
+| Company | $297/mo | 20 | 1,000,000 | 10 |
+| Agency | $497/mo | 100 | 10,000,000 | 50 |
+| Enterprise | Custom | Unlimited | Unlimited | Unlimited |
 
-| Name | Role | Default Model |
-|------|------|--------------|
-| exe | COO | claude-opus-4-6 |
-| yoshi | CTO | claude-opus-4-6 |
-| mari | CMO | claude-sonnet-4-6 |
-| tom | Principal Engineer | claude-sonnet-4-6 |
-| sasha | Content Production | claude-sonnet-4-6 |
+Activate: `exe-os --activate <key>` or paste during `exe-os setup`.
 
-## Configuration
+Purchase at [askexe.com](https://askexe.com).
 
-### Providers
+---
 
-Set API keys as environment variables:
+## Employee Templates
+
+Create employees with built-in templates:
 
 ```bash
-export ANTHROPIC_API_KEY=sk-...
-export OPENCODE_API_KEY=...     # optional
-export GEMINI_API_KEY=...       # optional
+exe-new-employee yoshi --template yoshi    # CTO
+exe-new-employee mari --template mari      # CMO
+exe-new-employee tom --template tom        # Principal Engineer
+exe-new-employee sasha --template sasha    # Content Specialist
+exe-new-employee gen --template gen        # AI Specialist
 ```
 
-Failover chain: Anthropic -> OpenCode -> Gemini -> OpenAI.
+Or create custom employees:
 
-### Settings
+```bash
+exe-new-employee alex                      # custom specialist
+```
 
-Run `/exe-settings` or view the Settings tab in the TUI:
+Each employee gets an identity doc at `~/.exe-os/identity/{name}.md`, a task folder, and launcher commands.
 
-- **Memory**: SQLCipher encryption, Jina embeddings, hybrid search
-- **Runtime**: consolidation (6h), skill learning (threshold: 3)
-- **Per-employee models**: configurable in `~/.exe-os/config.json`
+---
+
+## For Agencies
+
+See [docs/Agency-Playbook.md](docs/Agency-Playbook.md) for multi-client VPS deployment:
+- One VPS, multiple clients, full data isolation
+- Per-client wiki workspaces
+- Cross-client querying for agency owners
+- Config-driven white-label theming via `branding.json`
+
+---
+
+## Commands
+
+| Command | What it does |
+|---------|-------------|
+| `exe-os` | Launch TUI dashboard (Mode 2) |
+| `exe-os setup` | Run setup wizard |
+| `exe-os claude` | Install hooks + MCP into Claude Code (Mode 1) |
+| `exe-os --activate <key>` | Activate a license key |
+| `exe` | Launch your COO in Claude Code |
+| `exe-new-employee <name>` | Create a new employee |
+| `/exe` | Boot your COO (inside Claude Code) |
+| `/exe-team` | Show employee roster |
+| `/exe-search <query>` | Search memories |
+
+---
 
 ## Architecture
 
 ```
 exe-os/
   src/
-    tui/          # Ink-based terminal UI (7 tabs, keyboard nav)
-    runtime/      # Agent loop, tool registry, hooks, permissions
-    gateway/      # External agent adapters, failover, providers
-    lib/          # Core: memory, tasks, behaviors, search, sync
-    mcp/          # MCP server (9 tools for Claude Code integration)
-    adapters/     # Claude Code hooks (ingest, session-start, etc.)
+    lib/          # Core: memory, tasks, identity, behaviors, search, sync, encryption
+    mcp/          # MCP server (20+ tools for Claude Code integration)
+    adapters/     # Claude Code hooks (ingest, session-start, pre-tool-use, etc.)
+    tui/          # Ink-based terminal dashboard (Mode 2)
+    runtime/      # Agent loop, tool registry, permissions (Mode 2 standalone)
+    gateway/      # External messaging (WhatsApp, Telegram, Discord, webhook)
+  deploy/
+    compose/      # Docker Compose for VPS deployment (CRM + wiki + gateway + daemon)
+    Dockerfile*   # Per-service Docker images
+  docs/
+    Agency-Playbook.md  # Multi-client VPS guide
 ```
 
-**Storage**: libSQL (SQLCipher) for encrypted local-first data. Vector search via Jina v5 embeddings (GGUF, runs locally via daemon).
+**Three runtime modes:**
+
+| Mode | Entry | What you see |
+|------|-------|-------------|
+| Mode 1: Claude Code | `exe` | Claude Code terminal with COO identity |
+| Mode 2: TUI Dashboard | `exe-os` | Terminal dashboard with sidebar + team view |
+| Mode 3: Desktop | `exe-os desktop` | Tauri native app (coming soon) |
+
+**Storage:** SQLCipher (encrypted SQLite) + Jina v5 embeddings (local, 1024-dim). No data leaves your machine unless you opt into Exe Cloud (E2EE).
+
+---
+
+## Requirements
+
+- **Node.js 20+**
+- **tmux** — for multi-agent session management
+- **Claude Code** subscription (Mode 1) or API key (Mode 2)
+
+```bash
+# macOS
+brew install tmux node
+
+# Linux
+apt install tmux nodejs
+```
 
-**Security**: External agents run in ExternalAgentMode with deny-by-default guardrails. No bash, no file writes, no git — only whitelisted MCP tools. Audit trail on every permission decision.
+---
 
 ## License
 
-CC-BY-NC-4.0
+CC-BY-NC-4.0 (non-commercial). Commercial licenses available at [askexe.com](https://askexe.com).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@askexenow/exe-os",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "AI employee operating system — persistent memory, task management, and multi-agent coordination for Claude Code.",
   "license": "CC-BY-NC-4.0",
   "type": "module",