Server heirarchy removal

CHAT_CONTEXT_REFACTOR.md

@@ -0,0 +1,252 @@
+# Chat Context Refactor
+
+**Files to focus on:**
+- `apps/mobile/src/context/ChatContext.tsx`
+- `apps/mobile/src/components/chat/ChatInput.tsx` - for the secnding messages to agent endpoint functionality
+
+## Summary
+
+`apps/mobile/src/context/ChatContext.tsx` needs a refactor
+
+## Situation Analysis
+
+## Current ChatContext.tsx notes
+
+_at commit `fe7dd4d76d8695490b61a4c4c473dc9c90640e8e`_
+_focus file: `apps/mobile/src/context/ChatContext.tsx`_
+
+- I like the `agentStatus` (line 36) for error handling, but it might be redundant with `mcpConnectionStatus` (line 32), `agentConnectionStatus` (line 33) and isLoading (line 25)
+- Regarding `messages` (line 24) are we just holding all the messages that are shown on the screen? Should we think of Tides as a context window/conversationr rather than a daily flow?
+- Maybe the Chat Context responsibiilities should be split apart from the Tides Context responsibiities?
+
+### Example New Context Format
+
+```
+TimeContext (device time/location - stable)
+├── TideContext (NEW - tide data & conversation persistence)  
+    ├── ChatContext (NEW - pure UI communication layer)
+```
+
+TIME CONTEXT (`apps/mobile/src/context/TimeContext.tsx`) - Time & Location from user device. Context compoennt is currently stable. _If Tides is a conversation, TIME CONTEXT is the outside world_
+
+TIDE CONTEXT - Current Tide Messages from the User, the CLoudflare Worker, and from the System (Mobile Client). These messages should be held in sessions torage or soemthign similar. Maybe add a functionality to clear the curretn tide and create a new daily tide by clicking a "New Tide" button that can go ont eh top right of `Home.tsx`. _If Tides is a conversation, TIDE CONTEXT is the room that the conversation takes place in_
+
+CHAT CONTEXT - The context could be responsible for "Is TimeContext loaded/ready?" and then "Is TideContext loaded/ready?" and then "are we connected to the worker/server?". And then ChatCOntext is ultimately responsible for sharing relevant/useful inforamtion to the Tides Server/Agent Entrypoint.
+
+## Ultimate Goals
+
+The Component responsible for the Agent/Worker Entrypoint connection (lets use `apps/mobile/src/components/chat/ChatInput.tsx` as an example for now) should only import functions and parameters from the CHAT CONTEXT
+
+- All relevant info from TIME CONTEXT and TIDE CONTEXT are held and handled by CHAT CONTEXT which feeds right into ChatInput
+- The info from TIDE CONTEXT and TIDE CONTEXT needs to be held by the ChatInput because the ChatInput will be passing all info the the "Tides" k2 Storage in Cloudflare int eh 006 ENV as well as Messages to teh Agen/Worker entrypoint.
+
+**It's easier to scale down what we are passing to the agent entrypoint rather than scale up**
+
+## Service Layer Analysis
+
+### agentService.ts - AI Communication Layer
+
+**Primary Responsibilities:**
+
+- AI conversation endpoint integration (`/ai/conversation`)
+- Tool intent classification and routing
+- Session and conversation ID management (lines 54-56)
+- Enhanced conversation context with message history (lines 340-346)
+- Fallback mechanisms for AI service unavailability (lines 380-392)
+- User ID extraction from API keys for hybrid auth
+
+**Key Methods:**
+
+- `sendMessage()` - Main AI conversation interface
+- `sendConversationMessage()` - Enhanced AI endpoint with context
+- `classifyToolIntent()` - Natural language to tool routing
+- `executeMCPTool()` - Direct MCP tool execution bridge
+
+### mcpService.ts - MCP Protocol Layer  
+
+**Primary Responsibilities:**
+
+- JSON-RPC 2.0 MCP protocol implementation
+- Direct tide tool execution (tide_create, tide_list, etc.)
+- Hierarchical flow management via `startSmartFlow()` (lines 305-325)
+- Context-aware operations with automatic daily tide creation
+- Connection health monitoring and retry logic
+
+**Key Methods:**
+
+- `tool()` - Generic MCP tool caller
+- `startSmartFlow()` - Always uses hierarchical flow system (ADR-003 compliant)
+- `getOrCreateTide()` - Automatic context management
+- `switchContext()` - Navigate between daily/weekly/monthly views
+
+## Addiitonal Notes
+
+- **Message Persistence**: Conversation history maintained per tide context  
+
+**Implementation Implications:**
+
+- Messages scoped to current Daily Tide, not global chat
+- Context switching preserves conversation history per daily tide
+- A User can now have multiple dialy tides
+- "New Tide" functionality creates the new daily tide/fresh converation
+- The CHatMessages will only shwo messages from teh current Tide in the Tide Context
+- Existing daily flow patterns continue working unchanged
+
+## Gameplan
+
+**TideContext (NEW):**
+
+- Current tide context management (daily/weekly/monthly) baked in but not focus
+- Conversation message persistence per tide
+- "New Tide" creation for fresh conversation contexts
+- Session storage for tide-scoped conversations
+
+**ChatContext (NEW - Clean Implementation):**
+
+- Pure UI state management (single consolidated connection state)
+- Agent communication orchestration (agentService integration)
+- Tool execution coordination (mcpService bridge)
+- Clean interface for ChatInput component
+
+**ChatInput Integration Pattern:**
+
+```typescript
+// Single import pattern (Option 1)
+const { sendMessage, isLoading, isConnected } = useChat();
+// ChatContext orchestrates TideContext + TimeContext internally
+```
+
+---
+
+# ADDENDUM: Post-Implementation Analysis & Next Steps
+
+**Status:** ✅ **Integration Complete - Working Successfully**  
+**Date:** 2025-09-08  
+**Agent Communication:** Fully functional end-to-end
+
+## ✅ Successfully Implemented
+
+### Bridge Layer Pattern Working
+- **useChatMessaging.ts** - Bridge layer successfully coordinates all contexts
+- **ChatInput.tsx** - Self-contained component with full send functionality
+- **Agent endpoint** - Receiving proper data structure:
+  ```json
+  {
+    "user_id": "...",
+    "tide_id": "tide_1757313819957_unpv4v4t959", 
+    "message": "user input",
+    "context": {
+      "tide_tool": "selectedTool", // optional
+      "tide": { /* full tide object */ },
+      "tideContext": "daily",
+      "timeContext": { "timestamp": "...", "timezone": "..." },
+      "conversationHistory": [/* recent messages */],
+      "toolSuggestions": ["createTide", "getTideList"]
+    }
+  }
+  ```
+
+### K2 Storage Structure Confirmed
+**Tide Object in K2:**
+```json
+{
+  "id": "tide_1757313819957_unpv4v4t959",
+  "name": "Daily Focus - Sep 8, 2025",
+  "description": "Automatically created daily tide for 2025-09-08",
+  "created_at": "2025-09-08T06:43:39.957Z",
+  "status": "active",
+  "flow_sessions": [],
+  "energy_updates": [],
+  "task_links": []
+}
+```
+
+**Messages Storage:** 
+- Currently in AsyncStorage: `tide_messages_tide_1757313819957_unpv4v4t959`
+- 4 messages successfully persisted locally
+- Agent responses with suggested tools working
+
+## 🎯 Next Priority: Agent Response Processing
+
+### Current Gap Analysis
+**✅ What's Working:**
+- Agent receives full rich context
+- Agent responds with content and suggested tools  
+- Messages stored locally per tide
+- Tide metadata persists in K2
+
+**❌ Missing Functionality:**
+- Agent responses not updating K2 tide object
+- Tool calls/suggestions not persisting to `flow_sessions`
+- Energy insights not saved to `energy_updates`
+- Task management not reflected in `task_links`
+- Rich agent interactions not updating tide state
+
+### Proposed Agent Response Handlers
+
+**1. Tool Execution Handler**
+```typescript
+// When agent suggests tools, execute via MCP and update tide
+if (response.suggestedTools) {
+  await mcpService.updateFlowSession(tideId, {
+    tools_suggested: response.suggestedTools,
+    conversation_context: message
+  });
+}
+```
+
+**2. Energy Analysis Handler**
+```typescript
+// When agent analyzes user energy/mood
+if (response.energyInsight) {
+  await mcpService.addEnergyToTide(tideId, response.energyInsight.level, {
+    agent_analysis: response.energyInsight.analysis,
+    timestamp: new Date().toISOString()
+  });
+}
+```
+
+**3. Task Link Handler**
+```typescript
+// When agent helps with task management
+if (response.taskRecommendations) {
+  for (const task of response.taskRecommendations) {
+    await mcpService.linkTaskToTide(tideId, task.url, task.title, 'agent_suggested');
+  }
+}
+```
+
+## 🚀 Immediate Next Steps
+
+### Phase 1: Message Display (Priority 1)
+- Display agent responses with proper formatting
+
+### Phase 2: Agent Response Processing (Priority 2) 
+- Add response parsing logic to extract structured data
+- Implement K2 tide object updates via MCP service calls
+- Sync agent insights back to tide state (flow_sessions, energy_updates, task_links)
+
+### Phase 3: Enhanced UI Integration
+- Display suggested tools as actionable buttons
+- Show energy insights in UI
+- Integrate task links with tide workflow
+
+## 🏗️ Technical Implementation Notes
+
+**Message Flow Architecture:**
+```
+User Input → ChatInput → Bridge Layer → Agent Service → Agent Response
+     ↓                                                        ↓
+AsyncStorage (messages) ← TideContext ← Response Handler → K2 Storage (tide updates)
+```
+
+**Key Integration Points:**
+- Bridge layer handles all context aggregation
+- Agent service manages AI communication  
+- Response handlers update K2 storage via MCP service
+- TideContext maintains local message persistence
+- ChatContext manages pure UI state
+
+---
+
+**Status:** Ready to implement message display and agent response processing