thetacog-mcp 1.0.0 → 1.0.1

package/README.md

@@ -1,176 +1,193 @@
 # ThetaCog MCP
 
-**Mode management, not task management.**
+**Transform your terminal into a mental palace.**
 
-A Claude MCP server that detects which cognitive room you should be in and helps you switch contexts with memory palace anchoring.
+Each terminal app is a cognitive room. Each room has its own browser tabs. `Cmd+Space kitty` switches to Kitty AND its associated tabs. The room remembers what you were doing.
 
-## The Pitch
+## The Model
 
-> "We don't use task lists. We have 56 terminals, each one a cognitive room. Command+Space to a room name, and you're in a different mode. The room remembers what you were doing. Join this startup. We work like rockstars."
+```
+Cmd+Space "kitty" →
+  1. Kitty terminal opens (Operator room)
+  2. Kitty's browser tabs are there (Vercel, Supabase, monitoring)
+  3. All other rooms are minimized tabs, interlinked
+  4. Claude knows you're in Operator mode
+```
+
+**This is not split-screen.** This is terminal + browser tab association. You prune your browser tabs to match each identity's theme.
 
 ## Install
 
+**Works with any MCP-compatible client** (Claude Code, Cursor, Cline, etc.)
+
 ```bash
 npm install -g thetacog-mcp
-npx thetacog install
-# Restart Claude Code
+
+# Claude Code (default)
+claude mcp add thetacog "npx thetacog-mcp"
+
+# Other MCP clients - add to your mcp config:
+# { "command": "npx", "args": ["thetacog-mcp"] }
 ```
 
-## Tools
+## The 6 Cognitive Rooms
 
-### thetacog-detect
+| Room | Terminal | Browser Tabs | Identity |
+|------|----------|--------------|----------|
+| **Builder** | iTerm2 | GitHub PRs, CI/CD, API docs | "I am shipping" |
+| **Operator** | Kitty | Vercel, Supabase, monitoring | "I am executing" |
+| **Discoverer** | WezTerm | Research, Stack Overflow, docs | "I am exploring" |
+| **Teacher** | Terminal | Blog drafts, content calendar, voice notes | "I am writing" |
+| **Strategist** | VS Code | Planning docs, competitor analysis | "I am positioning" |
+| **Experimenter** | Cursor | Prototypes, scratch files, POCs | "I am testing" |
 
-Analyze conversation to detect which room you should be in.
+**Tip:** Place each room's HTML dashboard tab next to your related apps. Teacher dashboard next to your messaging app. Operator dashboard next to Slack/Discord. The tabs cluster by theme.
 
-```
-You: "Actually let's think about the bigger picture"
+## How It Works
 
-Claude: [calls thetacog-detect]
-→ { room: "architect", confidence: 0.92, signal: "bigger picture" }
+1. **Each terminal is a room** - iTerm2 = Builder, Kitty = Operator, etc.
+2. **Each room has browser tabs** - Prune them to match the room's theme
+3. **Bundled HTML dashboards** - Starting points for your tabs (customize them)
+4. **All rooms interlinked** - Switch terminals, switch contexts, stay in flow
+5. **Your AI knows where you are** - MCP tools detect your terminal and room
 
-"That sounds like Architect thinking. Want to switch?"
-```
+**The terminal-to-dashboard link is symbolic.** You set up which browser tabs belong to which terminal. The system assumes you keep them pruned. This is Hebbian architecture - you train yourself by repetition.
 
-### thetacog-status
+## Tools (8 total)
 
-Get current room context, identity rules, and memory palace anchor.
+### thetacog-status
+Get current room context and identity rules.
 
 ```json
 {
-  "currentRoom": "builder",
-  "emoji": "🔨",
-  "memoryPalace": "Walk to the workshop. Blue light. Tools on the wall.",
-  "identityRules": [
-    "You are shipping, not theorizing",
-    "Done beats right when the demo is Sunday"
-  ]
+  "currentRoom": "operator",
+  "emoji": "⚙️",
+  "terminal": "Kitty",
+  "browserTabs": ["Vercel Dashboard", "Supabase", "Error Tracking"],
+  "identityRules": ["Execute, don't theorize", "Uptime is the metric"]
 }
 ```
 
 ### thetacog-switch
-
 Switch to a different room with context preservation.
 
 ```
-Claude: [calls thetacog-switch room="architect"]
+Claude: [calls thetacog-switch room="builder"]
 
-"Walk up the stairs to the drafting room. Indigo light.
-Unroll the blueprints. See the whole war before you fight it."
+"Switching to Builder room. Open iTerm2.
+Your GitHub PRs and CI dashboard are waiting."
 ```
 
 ### thetacog-open
-
 Open the HTML dashboard for a room in the browser.
 
 ```
-Claude: [calls thetacog-open room="builder"]
-→ Opens iterm2-builder.html in browser
+Claude: [calls thetacog-open room="operator"]
+→ Opens operator-dashboard.html in browser
 ```
 
 ### thetacog-todo
-
-Manage todos per room. SQLite primary, syncs to JSON for HTML.
+Manage priority lists per room. SQLite primary, syncs to JSON for HTML.
 
 ```
-Claude: [calls thetacog-todo action="add" room="builder" text="Ship Stripe" priority=1]
-Claude: [calls thetacog-todo action="list" room="builder"]
-Claude: [calls thetacog-todo action="update" id=1 done=true]
+Claude: [calls thetacog-todo action="add" room="operator" text="Deploy v2.1" priority=1]
+Claude: [calls thetacog-todo action="list" room="operator"]
 ```
 
 ### thetacog-stream
-
 Send messages between rooms (flywheel coordination).
 
 ```
-Claude: [calls thetacog-stream action="send" from="builder" to="architect" message="Stripe 80% done"]
-Claude: [calls thetacog-stream action="get" to="architect"]
-→ Returns unread input streams
+Claude: [calls thetacog-stream action="send" from="builder" to="operator" message="v2.1 ready for deploy"]
 ```
 
 ### thetacog-export
-
-Export full state to JSON file. HTML reads on tab focus.
+Export full state to JSON. HTML reads on tab focus.
 
 ### thetacog-terminal
-
-Detect which terminal Claude is running in.
+Detect which terminal the AI is running in.
 
 ```
-Claude: [calls thetacog-terminal]
-→ { terminal: "iTerm", room: "builder", html: "iterm2-builder.html" }
+AI: [calls thetacog-terminal]
+→ { terminal: "Kitty", room: "operator" }
 ```
 
-## Room Archetypes
-
-| Room | Emoji | Color | Tier | Identity |
-|------|-------|-------|------|----------|
-| **Builder** | 🔨 | Blue | Tactical | Ship, don't theorize. Done beats right. |
-| **Architect** | 📐 | Indigo | Strategic | See the whole war before you fight it. |
-| **Operator** | 🎩 | Green | Strategic | Close, don't explore. Revenue is the metric. |
-| **Vault** | 🔒 | Red | Foundational | Protect the irreversible. Prove, don't ship. |
-| **Voice** | 🎤 | Purple | Tactical | Test messaging. Experiment with variants. |
-| **Laboratory** | 🧪 | Cyan | Tactical | Break things safely. Prototype fast. |
-
-## Stakes Tiers
-
-- **Tactical** - Fully reversible, immediate horizon (Builder, Voice, Laboratory)
-- **Strategic** - Semi-reversible, 1-year horizon (Architect, Operator)
-- **Foundational** - Irreversible, multi-year horizon (Vault)
-
-## Terminal Mapping (macOS)
-
-| Terminal | Room |
-|----------|------|
-| iTerm2 | Builder |
-| VS Code | Architect |
-| Kitty | Operator |
-| WezTerm | Vault |
-| Terminal | Voice |
-| Cursor | Laboratory |
-
 ## Architecture
 
 ```
 ~/.thetacog/
-├── thetacog.db           # SQLite (primary store - fast for Claude)
+├── thetacog.db           # SQLite (primary store - fast MCP reads)
 ├── state.json            # JSON export (HTML reads on tab focus)
-└── rooms/                # Optional local HTML copies
+└── rooms/                # Local HTML copies
 
-.workflow/rooms/          # Git-tracked HTML files
-├── iterm2-builder.html   # Each has embedded JSON config
-├── vscode-architect.html
-└── ...
+.workflow/                # Bundled with npm install
+├── kitty-operator.html   # Operator room dashboard
+├── iterm2-builder.html   # Builder room dashboard
+├── messages-network.html # Messaging/communication hub
+├── terminal-voice.html   # Teacher/writing room
+└── ...                   # Starting points for your browser tabs
 ```
 
 **Data flow:**
-1. Claude writes to SQLite (fast, 0-1ms)
+1. MCP client writes to SQLite (0-1ms)
 2. Every write exports to `state.json`
-3. HTML reads `state.json` on `visibilitychange` (tab focus)
-4. No Node needed - pure browser JS
+3. HTML reads `state.json` on tab focus
+4. No server needed - pure browser JS
+
+## The Key Insight
+
+**Browser tabs are associated with terminals, not split alongside them.**
+
+When you `Cmd+Space kitty`:
+- Kitty opens (Operator terminal)
+- Your Operator browser tabs are right there (you keep them pruned)
+- The bundled HTML dashboard is one of those tabs
+- All rooms are interlinked - minimized tabs for other terminals
 
-**HTML files ARE the rooms.** SQLite is the source of truth. JSON is the sync layer. HTML refreshes on tab focus.
+This is Hebbian learning: "Neurons that fire together, wire together." Kitty + Operator tabs = Operator mindset.
 
-## Target Audience
+## Cloud Sync (Coming Soon)
 
-- ADHD founders who task-switch constantly
-- Parallel thinkers who follow intuition
-- Developers with 20+ terminal tabs open
-- Startups that want to "work like rockstars"
+Free tier works entirely offline with bundled HTML dashboards.
 
-**Not for:** Task lists, linear thinkers, rigid process
+Cloud tier ($1/month) adds:
+- Web dashboard at thetacoach.biz/thetacog (SQL-connected)
+- Cross-machine workspace sync
+- RetroAge prediction tracking
+- Same Supabase as ThetaCoach CRM
+
+## Who This Is For
+
+**The modern world is not a cognitively friendly place.**
+
+Slack pings. Email notifications. Open office plans. Context switching every 11 minutes on average. This environment was not designed for human cognition. It was designed for surveillance and availability metrics.
+
+You know the type. You may be one. The person with 20+ browser tabs because each tab is a thought. The founder who gets a strong intuition and needs to capture it before it evaporates. The developer who can produce 10x output in flow state but struggles to start.
+
+You have two options:
+1. **Take Concerta or Adderall** to make other people's environment tolerable
+2. **Redesign the environment** to match how your brain actually works
+
+This is option 2.
 
 ## Philosophy
 
 Context switching has a cost. But context switching within a well-designed system has almost no cost.
 
-When you Command+Space to a room name, you are not losing context. You are loading context. The room has the right tabs open. The room has Claude loaded with context. The room has identity rules visible.
+When you `Cmd+Space` to a terminal name, you are not losing context. You are loading context. The terminal has your AI assistant in that mode. The browser tabs match the work. The room remembers what you were doing.
+
+**Tool = Identity = Mindset.**
+
+You don't switch tasks. You switch rooms. And the room knows who you are when you're there.
 
-You do not switch tasks. You switch rooms. And the room remembers what you were doing there.
+Not task management. Mode management. Flow with the intuition. Let the rooms carry the context.
 
 ## Related
 
-- [Cognitive Rooms Blog Post](https://thetacoach.biz/blog/cognitive-rooms-flow-architecture)
-- [ThetaCoach CRM MCP](https://www.npmjs.com/package/thetacoach-crm-mcp) - Same architecture for sales battle cards
+- [Cognitive Rooms: A Flow Architecture for Parallel Founders](https://thetacoach.biz/blog/cognitive-rooms-flow-architecture) - The full methodology
+- [The Cognitive Flywheel: Why This Works](https://thetacoach.biz/blog/cognitive-workspace-adhd-flywheel) - The neuroscience and Trust Debt framework
+- [ThetaCog Product Page](https://thetacoach.biz/thetacog) - Setup wizard and web dashboard
+- [ThetaCoach CRM MCP](https://www.npmjs.com/package/thetacoach-crm-mcp) - Same Supabase, different tools
 
 ## License
 
@@ -178,4 +195,4 @@ MIT
 
 ---
 
-*For parallel founders who think in parallel.*
+*For people who think in parallel. You know who you are.*

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thetacog-mcp",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Transform your terminal into a mental palace. Cognitive workspaces with Split View mode switching. Tool = Identity = Mindset.",
   "type": "module",
   "main": "server.js",