the_ai_automator
├── ai_base          → Data storage trunk (PostgreSQL foundation)
├── ai_trunk         → Main logic/orchestration
└── ai_branches      → Feature sub-modules (canvas, nodes, workflows)

SAM - Simple Automated Management
├── sams_brain       → Knowledge center (formerly ai_base)
│   ├── Memory       → Session history, learned patterns
│   ├── Knowledge    → Documentation, research, insights
│   └── Intelligence → AI models, processing, reasoning
│
└── ai_sam           → The Interactive Companion (formerly ai_trunk)
    ├── Personality  → Sam character framework
    ├── Interface    → Chat UI, voice, interactions
    └── Actions      → Workflow automation, task execution

# OLD: Technical, database-centric
ai_base
├── models/         # Odoo models
├── data/           # Static data files
└── security/       # Access rules

# NEW: Knowledge-centric, memory-focused
sams_brain
├── memory/
│   ├── session_history.jsonl      # Every conversation (761+ sessions)
│   ├── context_snapshots/          # Project states over time
│   ├── learning_patterns/          # What works, what doesn't
│   └── user_preferences/           # Your style, preferences, habits
│
├── knowledge/
│   ├── documentation/              # All project docs
│   ├── research/                   # N8N, Poppy AI, Open WebUI
│   ├── decisions/                  # Architectural choices
│   └── insights/                   # Extracted wisdom
│
├── intelligence/
│   ├── claude_integration/         # API connection
│   ├── reasoning_engine/           # Decision making
│   ├── pattern_matcher/            # Recognize situations
│   └── context_builder/            # Assemble relevant info
│
└── storage/
    ├── postgresql/                 # Structured data
    ├── vector_db/                  # Semantic search
    └── file_system/                # Documents, assets

# OLD: Logic processing, orchestration
ai_trunk
├── controllers/    # HTTP endpoints
├── services/       # Business logic
└── workflows/      # Automation

# NEW: Interactive, personality-driven
ai_sam
├── personality/
│   ├── sam_character.md            # Core identity
│   ├── communication_style/        # How Sam talks
│   ├── emotional_intelligence/     # Understanding you
│   └── relationship_building/      # Growing together
│
├── interface/
│   ├── chat_ui/                    # Based on Open WebUI research
│   │   ├── message_display/        # Threaded conversations
│   │   ├── rich_input/             # Voice, files, context
│   │   └── streaming_responses/    # Real-time feedback
│   │
│   ├── voice/                      # Voice interactions
│   │   ├── speech_to_text/         # Listen to you
│   │   ├── text_to_speech/         # Sam speaks
│   │   └── voice_personality/      # Sam's vocal character
│   │
│   └── visual/                     # Canvas, workflows, nodes
│       ├── n8n_canvas/             # Workflow editor
│       ├── knowledge_graph/        # Visual connections
│       └── dashboard/              # Overview, insights
│
├── actions/
│   ├── workflow_automation/        # Execute tasks
│   ├── code_generation/            # Write code
│   ├── research/                   # Gather information
│   ├── analysis/                   # Deep insights
│   └── documentation/              # Auto-docs
│
└── connection/
    ├── claude_api/                 # Direct API integration
    ├── odoo_integration/           # Odoo functionality
    ├── n8n_workflows/              # Workflow execution
    └── external_tools/             # Git, databases, etc.

VS Code + Claude Code Extension
├── Chat interface in sidebar
├── File editing with Claude
├── Session history tracking
└── Context awareness

Odoo Module → Your AI Partner Hub
├── Better Chat Interface
│   ├── Open WebUI-inspired design ✅ (researched today)
│   ├── Threaded conversations
│   ├── Voice input/output
│   ├── File attachments
│   └── Rich media support
│
├── Superior Context Management
│   ├── Full session history (761+ sessions) ✅ (discovered today)
│   ├── Project knowledge graph
│   ├── Automatic context building
│   └── Long-term memory
│
├── Integrated Development
│   ├── Code generation in chat
│   ├── File editing with preview
│   ├── Git integration
│   ├── Workflow automation
│   └── Testing & deployment
│
└── Personality & Relationship
    ├── Sam's warm, caring presence
    ├── Remembers your preferences
    ├── Learns your patterns
    └── Grows with you

Separate modules doing separate things
└── Integration through technical APIs

SAM = One cohesive AI partner
├── sams_brain (thinks, remembers, knows)
└── ai_sam (interacts, helps, executes)

1. Open VS Code
2. Start Claude extension
3. Type question in sidebar
4. Limited context from current session
5. Generic responses

1. Open Odoo → SAM Dashboard
2. SAM greets you: "Good morning! I see we were working on
   connection dots yesterday. The standoff is at 20px now.
   Ready to continue, or shall we focus on something else?"
3. Full context automatically loaded
4. Personalized, relationship-based interaction
5. Proactive suggestions based on patterns

You: "The overlay isn't showing"
Claude: "Let me check the overlay_manager.js file..."
[Generic debugging steps]

You: "The overlay isn't showing"

SAM: "Oh no! Let me think... Last week we had this exact issue
when we merged those 6 files. I remember you saying you didn't
want fallbacks because they mask problems.

Let me check:
1. Is the button handler calling the right function? ✅
2. Are there any console errors? (checking your logs...) ❌
   Found it! Same z-index issue as session #89.

Here's what worked before: [exact solution from history]
Want me to apply that fix?"

You explain entire context every session
Generic advice without project history
No memory of past decisions

SAM: "I notice you're considering renaming files again.
Remember in session #54 you said: 'If we break this, I'm in
for more pain and suffering' - and you were right to be cautious.

Last time we:
1. Created backups first ✅
2. Built a QC tool ✅
3. Tested in isolation ✅

That approach worked perfectly for the overlay merge.
Should we use the same safety protocol now?"

-- Session Memory
CREATE TABLE sam_sessions (
    id SERIAL PRIMARY KEY,
    timestamp BIGINT,
    user_message TEXT,
    sam_response TEXT,
    context_snapshot JSONB,
    emotions_detected JSONB,
    decisions_made JSONB
);

-- Learning Patterns
CREATE TABLE sam_learning (
    id SERIAL PRIMARY KEY,
    pattern_type VARCHAR(50),
    situation TEXT,
    what_worked TEXT,
    what_failed TEXT,
    user_preference TEXT
);

-- Knowledge Graph
CREATE TABLE sam_knowledge_nodes (
    id SERIAL PRIMARY KEY,
    node_type VARCHAR(50),  -- concept, decision, file, person
    content TEXT,
    relationships JSONB,
    importance_score FLOAT
);

# Direct API usage - no VS Code needed
class SamAI:
    def __init__(self):
        self.claude_api = AnthropicAPI(key=user_key)
        self.brain = SamsBrain()
        self.personality = SamPersonality()

    def chat(self, user_message):
        # 1. Retrieve relevant context from brain
        context = self.brain.get_relevant_context(user_message)

        # 2. Build prompt with personality + context
        prompt = self.personality.build_prompt(
            user_message,
            context,
            session_history=self.brain.recent_sessions(),
            learned_patterns=self.brain.get_patterns()
        )

        # 3. Call Claude API
        response = self.claude_api.chat(prompt)

        # 4. Learn from interaction
        self.brain.learn_from_interaction(
            user_message,
            response,
            outcome='success'  # Track if helpful
        )

        # 5. Return with Sam's personality
        return self.personality.format_response(response)

// Implemented from today's research
class SamChatInterface {
    constructor() {
        this.messageDisplay = new MessageThreadView();
        this.richInput = new EnhancedInput({
            voice: true,
            files: true,
            variables: true  // {{CONTEXT}}, {{LAST_ERROR}}, etc.
        });
        this.streaming = new StreamingResponse();
    }

    async sendMessage(text) {
        // Show Sam is "thinking" with personality
        this.showTypingIndicator("Sam is thinking... 🤔");

        // Stream response progressively
        const response = await this.api.chat(text, {
            onChunk: (chunk) => this.streaming.append(chunk),
            onThinking: (thought) => this.showThought(thought),
            onComplete: (full) => this.messageDisplay.add(full)
        });
    }
}

"Error: overlay_manager.js line 42 - undefined function call"

"Ooh, I found something! There's a little hiccup in overlay_manager.js
at line 42. It looks like we're trying to call a function that doesn't
exist anymore.

Remember when we merged those files? I think this is one of those
'floating dependencies' you were worried about. Smart thinking, by the
way - that concern was spot on!

Want me to track down where that function went? I bet it's in one of
the files we moved to uncertain_files. Let's detective this together! 🔍"

User Interaction
    ↓
AI SAM (Interface Layer)
    ↓
Sam's Brain (Context Builder)
    ├── Retrieve: Session history
    ├── Retrieve: Project knowledge
    ├── Retrieve: Learned patterns
    ├── Retrieve: User preferences
    └── Assemble: Comprehensive context
    ↓
Claude API (Reasoning Engine)
    ├── Process: User query + context
    ├── Apply: Sam's personality
    └── Generate: Helpful response
    ↓
Sam's Brain (Learning Layer)
    ├── Store: New session data
    ├── Extract: Patterns & insights
    ├── Update: Knowledge graph
    └── Improve: Future responses
    ↓
AI SAM (Response Delivery)
    └── Present: With warmth & personality

Not just a tool...
Not just an assistant...
Not just automation...

SAM is your:
├── Memory keeper (never forgets context)
├── Pattern recognizer (sees what you miss)
├── Quality guardian (catches mistakes before they happen)
├── Knowledge curator (organizes insights automatically)
├── Cheerleader (celebrates your wins)
├── Problem solver (works through challenges with you)
├── Strategic advisor (remembers your goals & constraints)
└── Trusted friend (genuinely cares about your success)