HUB-2: Threaded Messaging Architecture

Thread: "Deploy RAG++ update"
├── [human] Deploy the latest RAG++ to cloud-vm
├── [agent:claude] Building container...
├── [agent:claude] Deployed successfully to :8000
├── [system] Service health check: ✅ passing
└── [human] 👍

Thread: "#heartbeat — 2026-03-01"
├── [flow:heartbeat_pulse] 5/8 services healthy
├── [flow:heartbeat_pulse] 6/8 services healthy
├── [flow:infra_watchdog] ⚠️ Graph Kernel timeout (2 consecutive)
└── [flow:heartbeat_pulse] 8/8 services healthy ✅

Thread: "Pulse: Fix auth token refresh"
├── [pulse] Session started (max 10 iterations)
├── [pulse:iter-1] Read auth code, identified stale token path
├── [pulse:iter-2] Implemented token refresh logic
├── [pulse:iter-3] Tests passing, committing
└── [pulse] ✅ COMPLETE — 3 iterations, 4 files modified

Thread: "Task: Build iOS widget"
├── [dispatch] Task created → assigned to mac1-claude
├── [agent:claude] Starting task...
├── [agent:claude] Widget implemented, building...
├── [system] Build succeeded (exit code 0)
└── [dispatch] ✅ Task completed — quality score 0.92

Thread: "🔴 Alert: Mac4 unreachable"
├── [watchdog] Mac4 unreachable for 2 hours
├── [watchdog] Auto-restart attempted: Graph Kernel
├── [watchdog] Mac4 back online
└── [system] Alert resolved — downtime: 2h 14m

-- Core threading
CREATE TABLE hub_threads (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    type TEXT NOT NULL CHECK (type IN ('conversation', 'feed', 'pulse', 'dispatch', 'alert')),
    category TEXT NOT NULL,           -- 'agent', 'heartbeat', 'pulse-control', etc.
    title TEXT NOT NULL,
    subtitle TEXT,                     -- e.g., flow name, agent name
    created_by UUID REFERENCES auth.users(id),
    agent_id TEXT,                     -- assigned agent (for conversation/dispatch)
    model TEXT,                        -- claude/gemini/ollama
    session_key TEXT,                  -- gateway session key
    pulse_session_id TEXT,             -- for pulse threads
    mac_task_id UUID,                  -- for dispatch threads
    severity TEXT,                     -- for alert threads
    is_resolved BOOLEAN DEFAULT false,
    is_pinned BOOLEAN DEFAULT false,
    is_muted BOOLEAN DEFAULT false,
    last_message_at TIMESTAMPTZ,
    message_count INTEGER DEFAULT 0,
    unread_count INTEGER DEFAULT 0,   -- per-user (computed client-side)
    metadata JSONB DEFAULT '{}',
    created_at TIMESTAMPTZ DEFAULT now(),
    updated_at TIMESTAMPTZ DEFAULT now()
);

CREATE TABLE hub_messages (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    thread_id UUID NOT NULL REFERENCES hub_threads(id) ON DELETE CASCADE,
    sender_type TEXT NOT NULL CHECK (sender_type IN ('human', 'agent', 'system', 'flow', 'pulse', 'dispatch')),
    sender_id TEXT,                    -- user ID, agent name, flow name
    sender_label TEXT,                 -- display name
    content TEXT NOT NULL,
    content_type TEXT DEFAULT 'text' CHECK (content_type IN ('text', 'markdown', 'embed', 'code', 'image', 'voice_note', 'system')),
    embed_data JSONB,                  -- for rich embeds (like Discord webhook payloads)
    reply_to UUID REFERENCES hub_messages(id),
    iteration_number INTEGER,          -- for pulse messages
    is_streaming BOOLEAN DEFAULT false,
    metadata JSONB DEFAULT '{}',
    created_at TIMESTAMPTZ DEFAULT now()
);

CREATE TABLE hub_reactions (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    message_id UUID NOT NULL REFERENCES hub_messages(id) ON DELETE CASCADE,
    user_id UUID REFERENCES auth.users(id),
    emoji TEXT NOT NULL,
    created_at TIMESTAMPTZ DEFAULT now(),
    UNIQUE(message_id, user_id, emoji)
);

CREATE TABLE hub_thread_reads (
    thread_id UUID NOT NULL REFERENCES hub_threads(id) ON DELETE CASCADE,
    user_id UUID NOT NULL REFERENCES auth.users(id),
    last_read_at TIMESTAMPTZ DEFAULT now(),
    PRIMARY KEY (thread_id, user_id)
);

CREATE TABLE hub_bookmarks (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    user_id UUID NOT NULL REFERENCES auth.users(id),
    thread_id UUID REFERENCES hub_threads(id),
    message_id UUID REFERENCES hub_messages(id),
    note TEXT,
    created_at TIMESTAMPTZ DEFAULT now()
);

-- Indexes
CREATE INDEX idx_hub_messages_thread ON hub_messages(thread_id, created_at);
CREATE INDEX idx_hub_threads_category ON hub_threads(category, last_message_at DESC);
CREATE INDEX idx_hub_threads_type ON hub_threads(type, last_message_at DESC);
CREATE INDEX idx_hub_messages_sender ON hub_messages(sender_type, sender_id);

Channel: hub_messages   — INSERT events → live message delivery
Channel: hub_threads    — UPDATE events → unread count, last_message_at
Filter: thread_id = {current_thread}  — only subscribe to visible threads

-- All authenticated users can read all threads and messages
-- (OpenClaw Hub is single-user, but RLS keeps data organized)
ALTER TABLE hub_threads ENABLE ROW LEVEL SECURITY;
ALTER TABLE hub_messages ENABLE ROW LEVEL SECURITY;

CREATE POLICY "read_all_threads" ON hub_threads FOR SELECT TO authenticated USING (true);
CREATE POLICY "insert_threads" ON hub_threads FOR INSERT TO authenticated WITH CHECK (true);
CREATE POLICY "update_own_threads" ON hub_threads FOR UPDATE TO authenticated USING (true);

CREATE POLICY "read_all_messages" ON hub_messages FOR SELECT TO authenticated USING (true);
CREATE POLICY "insert_messages" ON hub_messages FOR INSERT TO authenticated WITH CHECK (true);

AppReducer
├── AuthFeature
├── ThreadListFeature          ← NEW: replaces ChannelView
│   ├── State: threads, filter, selectedThread
│   ├── Action: loadThreads, selectThread, createThread, muteThread
│   └── Dependency: HubClient (Supabase)
├── ThreadDetailFeature        ← NEW: message view + compose
│   ├── State: messages, isStreaming, compose
│   ├── Action: sendMessage, loadMore, react, bookmark
│   └── Dependencies: HubClient, ClawdbotBridge, GatewayWebSocketClient
├── QuadViewFeature            ← NEW: 4 concurrent threads
│   ├── State: quadrants[4], layout, focusedQuadrant
│   ├── Action: assignThread, swapQuadrant, toggleFocus
│   └── Child: ThreadDetailFeature × 4
├── FeedAggregatorFeature      ← NEW: unified feed timeline
│   ├── State: feeds, filters, timeline
│   ├── Action: loadFeeds, filterByCategory, markRead
│   └── Dependency: HubClient
├── FleetOverviewFeature       (existing from ACC)
├── PulseChainFeature          (existing from ACC)
├── ServiceHealthFeature       ← NEW: from infra_watchdog data
├── SettingsFeature            (existing from ACC)
└── SearchEverythingFeature    (existing from ACC, updated for threads)

┌─────────────────────────────────────────────────┐
│  [Threads]  [Quad]  [Feeds]  [Fleet]  [Settings]│
└─────────────────────────────────────────────────┘

┌───────────────────┬───────────────────┐
│  Thread A          │  Thread B          │
│  (conversation)    │  (heartbeat feed)  │
│                    │                    │
├───────────────────┼───────────────────┤
│  Thread C          │  Thread D          │
│  (pulse session)   │  (dispatch)        │
│                    │                    │
└───────────────────┴───────────────────┘

# webhook_poster.py — add Supabase posting
async def post_to_hub(thread_category: str, content: str, embed_data: dict = None):
    """Post to Supabase hub_messages (new path)."""
    supabase = get_supabase_client()

    # Find or create today's feed thread
    thread = await find_or_create_feed_thread(supabase, thread_category)

    # Insert message
    await supabase.table('hub_messages').insert({
        'thread_id': thread['id'],
        'sender_type': 'flow',
        'sender_id': f'flow:{thread_category}',
        'sender_label': thread_category.replace('-', ' ').title(),
        'content': content,
        'content_type': 'embed' if embed_data else 'markdown',
        'embed_data': embed_data,
    }).execute()

async def post_to_webhook(channel: str, embeds: list, ...):
    """Existing Discord webhook posting."""
    # ... existing code ...

    # Also post to hub (dual-post)
    for embed in embeds:
        await post_to_hub(channel, format_embed_as_markdown(embed), embed)

struct EmbedView: View {
    let embed: EmbedData  // title, description, color, fields, footer, timestamp

    var body: some View {
        VStack(alignment: .leading, spacing: 8) {
            // Color bar on left edge (like Discord)
            HStack(spacing: 0) {
                Rectangle()
                    .fill(Color(hex: embed.color))
                    .frame(width: 3)

                VStack(alignment: .leading, spacing: 6) {
                    if let title = embed.title {
                        Text(title).font(.subheadline).bold()
                    }
                    if let desc = embed.description {
                        Text(desc).font(.caption).foregroundStyle(.secondary)
                    }
                    // Fields grid
                    LazyVGrid(columns: embed.fields.map { _ in GridItem() }) {
                        ForEach(embed.fields) { field in
                            VStack(alignment: .leading) {
                                Text(field.name).font(.caption2).foregroundStyle(.tertiary)
                                Text(field.value).font(.caption).bold()
                            }
                        }
                    }
                    // Footer
                    if let footer = embed.footer {
                        Text(footer).font(.caption2).foregroundStyle(.tertiary)
                    }
                }
                .padding(10)
            }
            .background(.ultraThinMaterial)
            .cornerRadius(8)
        }
    }
}