@clawchatsai/connector 0.0.83 → 0.0.84

package/server.js

@@ -793,728 +793,6 @@ function cleanGatewaySessionsByPrefix(prefix) {
   }
 }
 
-// ─── Route Handlers ─────────────────────────────────────────────────────────
-
-// --- User settings (synced across devices) ---
-const SETTINGS_FILE = path.join(DATA_DIR, 'settings.json');
-
-function handleGetSettings(req, res) {
-  try {
-    const data = fs.existsSync(SETTINGS_FILE)
-      ? JSON.parse(fs.readFileSync(SETTINGS_FILE, 'utf8'))
-      : {};
-    return send(res, 200, data);
-  } catch {
-    return send(res, 200, {});
-  }
-}
-
-async function handleSaveSettings(req, res) {
-  const body = await parseBody(req);
-  try {
-    // Merge with existing settings
-    const existing = fs.existsSync(SETTINGS_FILE)
-      ? JSON.parse(fs.readFileSync(SETTINGS_FILE, 'utf8'))
-      : {};
-    const merged = { ...existing, ...body };
-    fs.writeFileSync(SETTINGS_FILE, JSON.stringify(merged, null, 2));
-    return send(res, 200, merged);
-  } catch (err) {
-    return send(res, 500, { error: err.message });
-  }
-}
-
-// --- Workspaces ---
-
-function handleGetWorkspaces(req, res) {
-  const ws = getWorkspaces();
-  const sorted = Object.values(ws.workspaces).sort((a, b) => (a.order ?? 999) - (b.order ?? 999));
-
-  // Add unread_count for each workspace (from thread unread_count column, kept in sync by mark-read + WS handler)
-  for (const workspace of sorted) {
-    try {
-      const db = getDb(workspace.name);
-      const result = db.prepare('SELECT COALESCE(SUM(unread_count), 0) as total FROM threads').get();
-      workspace.unread_count = result.total;
-    } catch (e) {
-      workspace.unread_count = 0;
-    }
-  }
-
-  send(res, 200, {
-    active: ws.active,
-    workspaces: sorted,
-  });
-}
-
-async function handleCreateWorkspace(req, res) {
-  const body = await parseBody(req);
-  const { name, label } = body;
-  if (!name || !/^[a-z0-9-]{1,32}$/.test(name)) {
-    return sendError(res, 400, 'Name must be [a-z0-9-], 1-32 chars');
-  }
-  const ws = getWorkspaces();
-  if (ws.workspaces[name]) {
-    return sendError(res, 409, 'Workspace already exists');
-  }
-  let agent = 'main';
-  try { agent = validateAgent(body.agent || 'main'); } catch { agent = 'main'; }
-  const workspace = { name, label: label || name, color: body.color || null, icon: body.icon || null, agent, createdAt: Date.now() };
-  ws.workspaces[name] = workspace;
-  setWorkspaces(ws);
-  // Initialize DB
-  getDb(name);
-  send(res, 201, { workspace });
-}
-
-async function handleUpdateWorkspace(req, res, params) {
-  const body = await parseBody(req);
-  const ws = getWorkspaces();
-  if (!ws.workspaces[params.name]) {
-    return sendError(res, 404, 'Workspace not found');
-  }
-  if (body.label !== undefined) {
-    ws.workspaces[params.name].label = body.label;
-  }
-  if (body.color !== undefined) {
-    ws.workspaces[params.name].color = body.color;
-  }
-  if (body.icon !== undefined) {
-    ws.workspaces[params.name].icon = body.icon;
-  }
-  if (body.lastThread !== undefined) {
-    ws.workspaces[params.name].lastThread = body.lastThread;
-  }
-  let migratedThreads = 0;
-  if (body.agent !== undefined) {
-    let newAgent;
-    try { newAgent = validateAgent(body.agent); } catch (e) { return sendError(res, 400, e.message); }
-    const oldAgent = ws.workspaces[params.name].agent || 'main';
-    if (newAgent !== oldAgent) {
-      const db = getDb(params.name);
-      const threads = db.prepare(
-        `SELECT id, session_key FROM threads WHERE session_key LIKE ?`
-      ).all(`agent:${oldAgent}:${params.name}:chat:%`);
-      db.prepare(`
-        UPDATE threads
-        SET session_key = replace(
-          session_key,
-          'agent:' || ? || ':' || ? || ':chat:',
-          'agent:' || ? || ':' || ? || ':chat:'
-        )
-        WHERE session_key LIKE 'agent:' || ? || ':' || ? || ':chat:%'
-      `).run(oldAgent, params.name, newAgent, params.name, oldAgent, params.name);
-      for (const t of threads) cleanGatewaySession(t.session_key);
-      ws.workspaces[params.name].agent = newAgent;
-      migratedThreads = threads.length;
-      gatewayClient.broadcastToBrowsers(JSON.stringify({
-        type: 'clawchats',
-        event: 'workspace-agent-changed',
-        workspace: params.name,
-        agent: newAgent
-      }));
-    }
-  }
-  setWorkspaces(ws);
-  send(res, 200, { workspace: ws.workspaces[params.name], migratedThreads });
-}
-
-function handleDeleteWorkspace(req, res, params) {
-  const ws = getWorkspaces();
-  console.log('DELETE workspace:', params.name, 'workspaces:', Object.keys(ws.workspaces), 'active:', ws.active);
-  if (!ws.workspaces[params.name]) {
-    return sendError(res, 404, 'Workspace not found');
-  }
-  if (Object.keys(ws.workspaces).length <= 1) {
-    return sendError(res, 400, 'Cannot delete the only workspace');
-  }
-  // Close and remove DB
-  closeDb(params.name);
-  const dbPath = path.join(DATA_DIR, `${params.name}.db`);
-  try { fs.unlinkSync(dbPath); } catch { /* ok */ }
-  try { fs.unlinkSync(dbPath + '-wal'); } catch { /* ok */ }
-  try { fs.unlinkSync(dbPath + '-shm'); } catch { /* ok */ }
-
-  // Clean all gateway sessions for this workspace
-  const wsAgentForDelete = ws.workspaces[params.name]?.agent || 'main';
-  const cleaned = cleanGatewaySessionsByPrefix(`agent:${wsAgentForDelete}:${params.name}:chat:`);
-  if (cleaned > 0) {
-    console.log(`Cleaned ${cleaned} gateway sessions for workspace: ${params.name}`);
-  }
-
-  delete ws.workspaces[params.name];
-
-  // If this was the active workspace, switch active to the first remaining one
-  if (ws.active === params.name) {
-    ws.active = Object.keys(ws.workspaces)[0] || null;
-  }
-
-  setWorkspaces(ws);
-  send(res, 200, { ok: true });
-}
-
-async function handleReorderWorkspaces(req, res) {
-  const body = await parseBody(req);
-  const { order } = body;
-  if (!Array.isArray(order)) {
-    return sendError(res, 400, 'order must be an array of workspace names');
-  }
-  const ws = getWorkspaces();
-  // Assign order index to each workspace
-  order.forEach((name, i) => {
-    if (ws.workspaces[name]) {
-      ws.workspaces[name].order = i;
-    }
-  });
-  setWorkspaces(ws);
-  send(res, 200, { ok: true, workspaces: Object.values(ws.workspaces) });
-}
-
-function handleActivateWorkspace(req, res, params) {
-  const ws = getWorkspaces();
-  if (!ws.workspaces[params.name]) {
-    return sendError(res, 404, 'Workspace not found');
-  }
-  ws.active = params.name;
-  setWorkspaces(ws);
-  // Pre-open the DB
-  getDb(params.name);
-  send(res, 200, { ok: true, workspace: ws.workspaces[params.name] });
-}
-
-// --- Threads ---
-
-function handleGetThreads(req, res, params, query) {
-  const db = getActiveDb();
-  const page = parseInt(query.page || '1', 10);
-  const limit = Math.min(parseInt(query.limit || '50', 10), 200);
-  const offset = (page - 1) * limit;
-  const search = query.search || '';
-
-  let threads, total;
-  if (search) {
-    // FTS5 search across messages, return matching thread IDs
-    try {
-      const ftsQuery = `
-        SELECT DISTINCT m.thread_id
-        FROM messages m
-        JOIN messages_fts ON messages_fts.rowid = m.rowid
-        WHERE messages_fts MATCH ?
-      `;
-      const matchingIds = db.prepare(ftsQuery).all(search).map(r => r.thread_id);
-      if (matchingIds.length === 0) {
-        return send(res, 200, { threads: [], total: 0, page });
-      }
-      const placeholders = matchingIds.map(() => '?').join(',');
-      total = db.prepare(
-        `SELECT COUNT(*) as c FROM threads WHERE id IN (${placeholders})`
-      ).get(...matchingIds).c;
-      threads = db.prepare(
-        `SELECT t.*, (SELECT MAX(m.timestamp) FROM messages m WHERE m.thread_id = t.id) as last_message_at
-         FROM threads t WHERE t.id IN (${placeholders}) ORDER BY t.pinned DESC, t.sort_order DESC, t.updated_at DESC LIMIT ? OFFSET ?`
-      ).all(...matchingIds, limit, offset);
-    } catch (ftsErr) {
-      console.warn('[DB] FTS thread search failed, returning empty results:', ftsErr.message);
-      return send(res, 200, { threads: [], total: 0, page });
-    }
-  } else {
-    total = db.prepare('SELECT COUNT(*) as c FROM threads').get().c;
-    threads = db.prepare(
-      `SELECT t.*, (SELECT MAX(m.timestamp) FROM messages m WHERE m.thread_id = t.id) as last_message_at
-       FROM threads t ORDER BY t.pinned DESC, t.sort_order DESC, t.updated_at DESC LIMIT ? OFFSET ?`
-    ).all(limit, offset);
-  }
-
-  send(res, 200, { threads, total, page });
-}
-
-function handleGetUnreadThreads(req, res) {
-  const db = getActiveDb();
-  const threads = db.prepare(`
-    SELECT t.id, t.title, t.unread_count, m.content as lastMessage
-    FROM threads t
-    LEFT JOIN messages m ON m.thread_id = t.id
-    WHERE t.unread_count > 0
-    AND m.timestamp = (SELECT MAX(timestamp) FROM messages WHERE thread_id = t.id)
-    ORDER BY t.updated_at DESC
-  `).all();
-
-  // Attach unread message IDs to each thread
-  for (const thread of threads) {
-    const rows = db.prepare('SELECT message_id FROM unread_messages WHERE thread_id = ?').all(thread.id);
-    thread.unreadMessageIds = rows.map(r => r.message_id);
-  }
-
-  send(res, 200, { threads });
-}
-
-async function handleMarkMessagesRead(req, res, params) {
-  const body = await parseBody(req);
-  const db = getActiveDb();
-  const threadId = params.id;
-  const messageIds = body.messageIds;
-
-  if (!Array.isArray(messageIds) || messageIds.length === 0) {
-    return send(res, 400, { error: 'messageIds array required' });
-  }
-
-  const placeholders = messageIds.map(() => '?').join(',');
-  db.prepare(`DELETE FROM unread_messages WHERE thread_id = ? AND message_id IN (${placeholders})`).run(threadId, ...messageIds);
-
-  // Sync unread_count from actual unread_messages table
-  const remaining = syncThreadUnreadCount(db, threadId);
-
-  // Broadcast unread-update to ALL browser clients (so other tabs/devices sync)
-  const workspace = getWorkspaces().active;
-  gatewayClient.broadcastToBrowsers(JSON.stringify({
-    type: 'clawchats',
-    event: 'unread-update',
-    workspace,
-    threadId,
-    action: 'read',
-    messageIds,
-    unreadCount: remaining,
-    timestamp: Date.now()
-  }));
-
-  send(res, 200, { unread_count: remaining });
-}
-
-async function handleCreateThread(req, res) {
-  const body = await parseBody(req);
-  const db = getActiveDb();
-  const ws = getWorkspaces();
-  const id = body.id || uuid();
-  const now = Date.now();
-  const workspaceAgent = ws.workspaces[ws.active]?.agent || 'main';
-  const sessionKey = `agent:${workspaceAgent}:${ws.active}:chat:${id}`;
-
-  try {
-    db.prepare(
-      'INSERT INTO threads (id, session_key, title, created_at, updated_at) VALUES (?, ?, ?, ?, ?)'
-    ).run(id, sessionKey, 'New chat', now, now);
-  } catch (e) {
-    if (e.message.includes('UNIQUE constraint')) {
-      return sendError(res, 409, 'Thread already exists');
-    }
-    throw e;
-  }
-
-  const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(id);
-  send(res, 201, { thread });
-}
-
-function handleGetThread(req, res, params) {
-  const db = getActiveDb();
-  const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(params.id);
-  if (!thread) return sendError(res, 404, 'Thread not found');
-  send(res, 200, { thread });
-}
-
-async function handleUpdateThread(req, res, params) {
-  const body = await parseBody(req);
-  const db = getActiveDb();
-  const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(params.id);
-  if (!thread) return sendError(res, 404, 'Thread not found');
-
-  const fields = [];
-  const values = [];
-  if (body.title !== undefined) { fields.push('title = ?'); values.push(body.title); }
-  if (body.pinned !== undefined) { fields.push('pinned = ?'); values.push(body.pinned ? 1 : 0); }
-  if (body.pin_order !== undefined) { fields.push('pin_order = ?'); values.push(body.pin_order); }
-  if (body.sort_order !== undefined) { fields.push('sort_order = ?'); values.push(body.sort_order); }
-  if (body.model !== undefined) { fields.push('model = ?'); values.push(body.model); }
-  if (body.last_session_id !== undefined) { fields.push('last_session_id = ?'); values.push(body.last_session_id); }
-  if (body.unread_count !== undefined) { fields.push('unread_count = ?'); values.push(body.unread_count); }
-
-  if (fields.length > 0) {
-    fields.push('updated_at = ?');
-    values.push(Date.now());
-    values.push(params.id);
-    db.prepare(`UPDATE threads SET ${fields.join(', ')} WHERE id = ?`).run(...values);
-  }
-
-  const updated = db.prepare('SELECT * FROM threads WHERE id = ?').get(params.id);
-  send(res, 200, { thread: updated });
-}
-
-function handleDeleteThread(req, res, params) {
-  const db = getActiveDb();
-  const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(params.id);
-  if (!thread) return sendError(res, 404, 'Thread not found');
-
-  // Delete from SQLite (CASCADE deletes messages)
-  db.prepare('DELETE FROM threads WHERE id = ?').run(params.id);
-
-  // Look up sessionId from SQLite or sessions.json as fallback
-  let sessionIdToDelete = thread.last_session_id;
-  const threadAgentMatch = (thread.session_key || '').match(/^agent:([^:]+):/);
-  const threadSessionsDir = getSessionsDirForAgent(threadAgentMatch?.[1]);
-  if (!sessionIdToDelete) {
-    try {
-      const raw = fs.readFileSync(path.join(threadSessionsDir, 'sessions.json'), 'utf8');
-      const store = JSON.parse(raw);
-      const entry = store[thread.session_key];
-      if (entry?.sessionId) sessionIdToDelete = entry.sessionId;
-    } catch { /* ok */ }
-  }
-
-  // Clean gateway session (deletes .jsonl + sessions.json entry)
-  cleanGatewaySession(thread.session_key);
-
-  // If cleanGatewaySession didn't find it but we have a sessionId, delete transcript directly
-  if (sessionIdToDelete) {
-    const jsonlPath = path.join(threadSessionsDir, `${sessionIdToDelete}.jsonl`);
-    try { fs.unlinkSync(jsonlPath); } catch { /* ok */ }
-  }
-
-  // Delete uploaded files
-  const uploadDir = path.join(UPLOADS_DIR, params.id);
-  try { fs.rmSync(uploadDir, { recursive: true }); } catch { /* ok */ }
-
-  send(res, 200, { ok: true });
-}
-
-// --- Messages ---
-
-function handleGetMessages(req, res, params, query) {
-  const db = getActiveDb();
-  const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(params.id);
-  if (!thread) return sendError(res, 404, 'Thread not found');
-
-  const limit = Math.min(parseInt(query.limit || '100', 10), 500);
-  const before = query.before ? parseInt(query.before, 10) : null;
-  const after = query.after ? parseInt(query.after, 10) : null;
-
-  let sql = 'SELECT * FROM messages WHERE thread_id = ?';
-  const sqlParams = [params.id];
-
-  if (before) {
-    sql += ' AND timestamp < ?';
-    sqlParams.push(before);
-  }
-  if (after) {
-    sql += ' AND timestamp > ?';
-    sqlParams.push(after);
-  }
-
-  // Count total matching for hasMore
-  const countSql = sql.replace('SELECT *', 'SELECT COUNT(*) as c');
-  const total = db.prepare(countSql).get(...sqlParams).c;
-
-  sql += ' ORDER BY timestamp DESC LIMIT ?';
-  sqlParams.push(limit + 1);
-
-  const rows = db.prepare(sql).all(...sqlParams);
-  const hasMore = rows.length > limit;
-  const messages = rows.slice(0, limit).reverse(); // Return chronological order
-
-  // Parse metadata JSON
-  for (const m of messages) {
-    if (m.metadata) {
-      try { m.metadata = JSON.parse(m.metadata); } catch { /* leave as string */ }
-    }
-  }
-
-  send(res, 200, { messages, hasMore });
-}
-
-async function handleCreateMessage(req, res, params) {
-  const body = await parseBody(req);
-  const db = getActiveDb();
-  const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(params.id);
-  if (!thread) return sendError(res, 404, 'Thread not found');
-
-  if (!body.id || !body.role || body.content === undefined || !body.timestamp) {
-    return sendError(res, 400, 'Required: id, role, content, timestamp');
-  }
-
-  const metadata = body.metadata ? JSON.stringify(body.metadata) : null;
-
-  // Idempotent upsert: insert or update status if it changed
-  const existing = db.prepare('SELECT id, status FROM messages WHERE id = ?').get(body.id);
-  if (existing) {
-    // Only update if status changes
-    if (body.status && body.status !== existing.status) {
-      db.prepare('UPDATE messages SET status = ?, content = ?, metadata = ? WHERE id = ?')
-        .run(body.status, body.content, metadata, body.id);
-    }
-  } else {
-    db.prepare(
-      'INSERT INTO messages (id, thread_id, role, content, status, metadata, seq, timestamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)'
-    ).run(body.id, params.id, body.role, body.content, body.status || 'sent', metadata, body.seq || null, body.timestamp, Date.now());
-
-    // Bump thread updated_at
-    db.prepare('UPDATE threads SET updated_at = ? WHERE id = ?').run(Date.now(), params.id);
-
-    // Heuristic title on first user message (mimics Claude/ChatGPT — title appears immediately on send)
-    if (body.role === 'user' && body.content) {
-      const threadInfo = db.prepare('SELECT title FROM threads WHERE id = ?').get(params.id);
-      if (threadInfo?.title === 'New chat') {
-        const heuristic = body.content.replace(/\n.*/s, '').slice(0, 40).trim()
-          + (body.content.length > 40 ? '...' : '');
-        if (heuristic) {
-          db.prepare('UPDATE threads SET title = ? WHERE id = ?').run(heuristic, params.id);
-          const activeWs = getWorkspaces().active;
-          gatewayClient.broadcastToBrowsers(JSON.stringify({
-            type: 'clawchats',
-            event: 'thread-title-updated',
-            threadId: params.id,
-            workspace: activeWs,
-            title: heuristic
-          }));
-        }
-      }
-    }
-  }
-
-  const message = db.prepare('SELECT * FROM messages WHERE id = ?').get(body.id);
-  if (message && message.metadata) {
-    try { message.metadata = JSON.parse(message.metadata); } catch { /* ok */ }
-  }
-  send(res, existing ? 200 : 201, { message });
-}
-
-function handleDeleteMessage(req, res, params) {
-  const db = getActiveDb();
-  const msg = db.prepare('SELECT id FROM messages WHERE id = ? AND thread_id = ?').get(params.messageId, params.id);
-  if (!msg) return sendError(res, 404, 'Message not found');
-  db.prepare('DELETE FROM messages WHERE id = ?').run(params.messageId);
-  send(res, 200, { ok: true });
-}
-
-// --- Context Fill ---
-
-function handleContextFill(req, res, params) {
-  const db = getActiveDb();
-  const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(params.id);
-  if (!thread) return sendError(res, 404, 'Thread not found');
-
-  const { preamble, method } = buildContextPreamble(db, params.id, thread.last_session_id, thread.session_key);
-  send(res, 200, { preamble, method });
-}
-
-// --- Search ---
-
-function handleSearch(req, res, params, query) {
-  const db = getActiveDb();
-  const q = query.q || '';
-  if (!q) return send(res, 200, { results: [], total: 0 });
-
-  const page = parseInt(query.page || '1', 10);
-  const limit = Math.min(parseInt(query.limit || '20', 10), 100);
-  const offset = (page - 1) * limit;
-
-  // FTS5 search with snippet
-  try {
-    const results = db.prepare(`
-      SELECT
-        m.id as messageId,
-        m.thread_id as threadId,
-        t.title as threadTitle,
-        m.role,
-        snippet(messages_fts, 0, '<mark>', '</mark>', '...', 40) as content,
-        m.timestamp
-      FROM messages_fts
-      JOIN messages m ON messages_fts.rowid = m.rowid
-      JOIN threads t ON m.thread_id = t.id
-      WHERE messages_fts MATCH ?
-      ORDER BY rank
-      LIMIT ? OFFSET ?
-    `).all(q, limit, offset);
-
-    const totalRow = db.prepare(`
-      SELECT COUNT(*) as c
-      FROM messages_fts
-      WHERE messages_fts MATCH ?
-    `).get(q);
-
-    send(res, 200, { results, total: totalRow.c });
-  } catch (ftsErr) {
-    console.warn('[DB] FTS message search failed, returning empty results:', ftsErr.message);
-    send(res, 200, { results: [], total: 0 });
-  }
-}
-
-// --- Export ---
-
-function handleExport(req, res) {
-  const db = getActiveDb();
-  const ws = getWorkspaces();
-  const threads = db.prepare('SELECT * FROM threads ORDER BY updated_at DESC').all();
-  const data = {
-    workspace: ws.active,
-    exportedAt: Date.now(),
-    threads: threads.map(t => {
-      const messages = db.prepare(
-        'SELECT * FROM messages WHERE thread_id = ? ORDER BY timestamp ASC'
-      ).all(t.id);
-      // Parse metadata
-      for (const m of messages) {
-        if (m.metadata) {
-          try { m.metadata = JSON.parse(m.metadata); } catch { /* ok */ }
-        }
-      }
-      return { ...t, messages };
-    }),
-  };
-  send(res, 200, data);
-}
-
-// --- Import ---
-
-async function handleImport(req, res) {
-  const body = await parseBody(req);
-  const db = getActiveDb();
-  const ws = getWorkspaces();
-
-  if (!body.threads || !Array.isArray(body.threads)) {
-    return sendError(res, 400, 'Expected { threads: [...] }');
-  }
-
-  let threadsImported = 0;
-  let messagesImported = 0;
-
-  const insertThread = db.prepare(
-    'INSERT OR IGNORE INTO threads (id, session_key, title, pinned, pin_order, model, last_session_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)'
-  );
-  const insertMsg = db.prepare(
-    'INSERT OR IGNORE INTO messages (id, thread_id, role, content, status, metadata, seq, timestamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)'
-  );
-
-  const importAll = db.transaction(() => {
-    for (const t of body.threads) {
-      if (!t.id) continue;
-      // TODO: per-project agent — import uses agent:main for now
-      const sessionKey = t.session_key || `agent:main:${ws.active}:chat:${t.id}`;
-      const result = insertThread.run(
-        t.id, sessionKey, t.title || 'Imported chat',
-        t.pinned || 0, t.pin_order || 0, t.model || null,
-        t.last_session_id || null, t.created_at || Date.now(), t.updated_at || Date.now()
-      );
-      if (result.changes > 0) threadsImported++;
-
-      const messages = t.messages || [];
-      for (const m of messages) {
-        if (!m.id || !m.role) continue;
-        const metadata = m.metadata ? (typeof m.metadata === 'string' ? m.metadata : JSON.stringify(m.metadata)) : null;
-        const r = insertMsg.run(
-          m.id, t.id, m.role, m.content || '', m.status || 'sent',
-          metadata, m.seq || null, m.timestamp || Date.now(), m.created_at || Date.now()
-        );
-        if (r.changes > 0) messagesImported++;
-      }
-    }
-  });
-
-  importAll();
-  send(res, 200, { ok: true, threadsImported, messagesImported });
-}
-
-// --- File Upload ---
-
-async function handleUpload(req, res, params) {
-  const db = getActiveDb();
-  const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(params.id);
-  if (!thread) return sendError(res, 404, 'Thread not found');
-
-  const files = await parseMultipart(req);
-  const threadUploadDir = path.join(UPLOADS_DIR, params.id);
-  fs.mkdirSync(threadUploadDir, { recursive: true });
-
-  const savedFiles = [];
-  for (const file of files) {
-    const fileId = uuid();
-    const ext = path.extname(file.filename) || '';
-    const savedName = fileId + ext;
-    const filePath = path.join(threadUploadDir, savedName);
-    fs.writeFileSync(filePath, file.data);
-    savedFiles.push({
-      id: fileId,
-      filename: file.filename,
-      path: `/api/uploads/${params.id}/${fileId}${ext}`,
-      mimeType: file.mimeType,
-      size: file.data.length,
-    });
-  }
-
-  send(res, 200, { files: savedFiles });
-}
-
-function handleServeUpload(req, res, params) {
-  const filePath = path.join(UPLOADS_DIR, params.threadId, params.fileId);
-  // Also try with common extensions
-  let resolved = filePath;
-  if (!fs.existsSync(resolved)) {
-    // Scan directory for file starting with fileId
-    const dir = path.join(UPLOADS_DIR, params.threadId);
-    try {
-      const entries = fs.readdirSync(dir);
-      const match = entries.find(e => e.startsWith(params.fileId.replace(/\.[^.]+$/, '')));
-      if (match) resolved = path.join(dir, match);
-    } catch { /* dir not found */ }
-  }
-
-  if (!fs.existsSync(resolved)) {
-    return sendError(res, 404, 'File not found');
-  }
-
-  const ext = path.extname(resolved).toLowerCase();
-  const mimeTypes = {
-    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
-    '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml',
-    '.pdf': 'application/pdf', '.txt': 'text/plain', '.json': 'application/json',
-  };
-  const contentType = mimeTypes[ext] || 'application/octet-stream';
-
-  const stat = fs.statSync(resolved);
-  res.writeHead(200, {
-    'Content-Type': contentType,
-    'Content-Length': stat.size,
-    'Cache-Control': 'public, max-age=86400',
-    'Access-Control-Allow-Origin': '*',
-  });
-  fs.createReadStream(resolved).pipe(res);
-}
-
-// ─── Intelligence (per-thread, per-workspace) ──────────────────────────────
-
-const INTELLIGENCE_DIR = path.join(DATA_DIR, 'intelligence');
-
-function getIntelligencePath(threadId) {
-  const workspace = getWorkspaces().active;
-  return path.join(INTELLIGENCE_DIR, workspace, `${threadId}.json`);
-}
-
-function handleGetIntelligence(req, res, params) {
-  const filePath = getIntelligencePath(params.id);
-  if (!fs.existsSync(filePath)) {
-    return send(res, 200, { versions: [], currentVersion: -1 });
-  }
-  try {
-    const data = JSON.parse(fs.readFileSync(filePath, 'utf8'));
-    return send(res, 200, data);
-  } catch (err) {
-    return send(res, 200, { versions: [], currentVersion: -1 });
-  }
-}
-
-async function handleSaveIntelligence(req, res, params) {
-  const body = await parseBody(req);
-  const filePath = getIntelligencePath(params.id);
-  const dir = path.dirname(filePath);
-  fs.mkdirSync(dir, { recursive: true });
-
-  // body should have { versions, currentVersion }
-  const data = {
-    versions: body.versions || [],
-    currentVersion: body.currentVersion ?? -1,
-    updatedAt: Date.now()
-  };
-  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
-  return send(res, 200, data);
-}
-
 // ─── File Serving (restricted to ~/.openclaw/media/) ────────────────────────
 
 const ALLOWED_FILE_DIRS = [
@@ -2041,169 +1319,6 @@ function createMemoryProvider(config) {
   return createQdrantProvider(config);
 }
 
-const memoryProvider = createMemoryProvider(MEMORY_CONFIG);
-// Initialize provider (auto-detect collection etc.) — runs async at startup
-memoryProvider.init().catch(err => console.error('Memory provider init error:', err.message));
-
-console.log(`Memory: provider=${MEMORY_CONFIG.provider} host=${MEMORY_CONFIG.host}:${MEMORY_CONFIG.port} collection=${MEMORY_CONFIG.collection || '(auto-detect)'}`);
-
-// ─── Memory Handlers ────────────────────────────────────────────────────────
-
-async function handleMemoryList(req, res, query) {
-  const limit = Math.min(parseInt(query.limit) || 20, 100);
-  try {
-    const result = await memoryProvider.list(limit, query.offset || null);
-    send(res, 200, result);
-  } catch (err) {
-    send(res, 502, { error: `Failed to reach ${memoryProvider.name}`, detail: err.message });
-  }
-}
-
-async function handleMemorySearch(req, res, query) {
-  const q = (query.query || '').toLowerCase().trim();
-  if (!q) return send(res, 400, { error: 'Missing query parameter' });
-  try {
-    const result = await memoryProvider.search(q);
-    send(res, 200, result);
-  } catch (err) {
-    send(res, 502, { error: `Failed to reach ${memoryProvider.name}`, detail: err.message });
-  }
-}
-
-const MEMORY_FILES_DIR = path.join(MEMORY_CONFIG.workspaceDir, 'memory');
-
-function parseMemoryFiles() {
-  const memories = [];
-  let files;
-  try {
-    files = fs.readdirSync(MEMORY_FILES_DIR);
-  } catch { return memories; }
-
-  for (const file of files) {
-    if (!file.endsWith('.md')) continue;
-    const filePath = path.join(MEMORY_FILES_DIR, file);
-    let stat;
-    try { stat = fs.statSync(filePath); } catch { continue; }
-    if (!stat.isFile()) continue;
-
-    const content = fs.readFileSync(filePath, 'utf8');
-    const basename = file.replace(/\.md$/, '');
-
-    // Extract date from filename (e.g. 2026-02-14 or 2026-02-09-topic-name)
-    const dateMatch = basename.match(/^(\d{4}-\d{2}-\d{2})/);
-    const fileDate = dateMatch ? dateMatch[1] : null;
-
-    // Split by ## headings into sections
-    const sections = content.split(/^(?=## )/m);
-    for (const section of sections) {
-      const trimmed = section.trim();
-      if (!trimmed) continue;
-
-      // Extract heading
-      const headingMatch = trimmed.match(/^##\s+(.+)/);
-      const heading = headingMatch ? headingMatch[1].trim() : null;
-      // Body is everything after heading line (or whole section if top-level)
-      const body = headingMatch ? trimmed.slice(trimmed.indexOf('\n') + 1).trim() : trimmed;
-
-      // Skip if it's just the top-level # heading with no real content
-      if (!heading && body.match(/^#\s+/) && body.split('\n').length <= 2) continue;
-
-      const title = heading || basename;
-      const id = `file:${basename}:${title}`;
-      memories.push({
-        id,
-        source: 'file',
-        file: basename,
-        title,
-        data: heading ? `**${title}**\n${body}` : body,
-        createdAt: fileDate ? `${fileDate}T00:00:00Z` : stat.mtime.toISOString(),
-      });
-    }
-  }
-
-  // Also scan subdirectories one level deep
-  try {
-    for (const entry of fs.readdirSync(MEMORY_FILES_DIR)) {
-      const subdir = path.join(MEMORY_FILES_DIR, entry);
-      if (!fs.statSync(subdir).isDirectory()) continue;
-      for (const file of fs.readdirSync(subdir)) {
-        if (!file.endsWith('.md')) continue;
-        const filePath = path.join(subdir, file);
-        const content = fs.readFileSync(filePath, 'utf8');
-        const basename = file.replace(/\.md$/, '');
-        const relPath = `${entry}/${basename}`;
-        const stat = fs.statSync(filePath);
-
-        memories.push({
-          id: `file:${relPath}`,
-          source: 'file',
-          file: relPath,
-          title: basename,
-          data: content.trim(),
-          createdAt: stat.mtime.toISOString(),
-        });
-      }
-    }
-  } catch { /* ignore */ }
-
-  return memories;
-}
-
-function handleMemoryFiles(req, res, query) {
-  const q = (query.query || '').toLowerCase().trim();
-  const memories = parseMemoryFiles();
-  const filtered = q
-    ? memories.filter(m => m.data.toLowerCase().includes(q) || m.title.toLowerCase().includes(q))
-    : memories;
-  // Sort newest first
-  filtered.sort((a, b) => (b.createdAt || '').localeCompare(a.createdAt || ''));
-  send(res, 200, { memories: filtered });
-}
-
-async function handleMemoryUpdate(req, res, params) {
-  const id = params.id;
-  try {
-    const chunks = [];
-    for await (const chunk of req) chunks.push(chunk);
-    const body = JSON.parse(Buffer.concat(chunks).toString());
-    const newData = (body.data || '').trim();
-    if (!newData) return send(res, 400, { error: 'Missing data field' });
-
-    const result = await memoryProvider.update(id, newData);
-    send(res, 200, { ok: true, result });
-  } catch (err) {
-    send(res, 502, { error: 'Failed to update memory', detail: err.message });
-  }
-}
-
-async function handleMemoryDelete(req, res, params) {
-  const id = params.id;
-  try {
-    const result = await memoryProvider.delete(id);
-    send(res, 200, { ok: true, result });
-  } catch (err) {
-    send(res, 502, { error: `Failed to reach ${memoryProvider.name}`, detail: err.message });
-  }
-}
-
-async function handleMemoryStatus(req, res) {
-  const status = await memoryProvider.status();
-  const filesExist = fs.existsSync(MEMORY_FILES_DIR);
-  send(res, 200, {
-    provider: memoryProvider.name,
-    host: MEMORY_CONFIG.host,
-    port: MEMORY_CONFIG.port,
-    collection: MEMORY_CONFIG.collection,
-    backend: status,
-    memoryFilesDir: MEMORY_FILES_DIR,
-    memoryFilesDirExists: filesExist,
-  });
-}
-
-// ─── Router ─────────────────────────────────────────────────────────────────
-
-// ─── Speech-to-text (Whisper API proxy) ─────────────────────────────────────
-
 async function handleTranscribe(req, res) {
   try {
     const chunks = [];
@@ -2261,1399 +1376,49 @@ async function handleTranscribe(req, res) {
   }
 }
 
-async function handleRequest(req, res) {
-  const _wsName = req.headers?.['x-workspace'];
-  const _requestDb = _wsName ? getDb(_wsName) : getActiveDb();
-  return _requestDbStore.run(_requestDb, () => _handleRequestImpl(req, res));
-}
 
-async function _handleRequestImpl(req, res) {
-  // Parse URL and query string
-  const [urlPath, queryString] = (req.url || '/').split('?');
-  const query = {};
-  if (queryString) {
-    for (const pair of queryString.split('&')) {
-      const [k, v] = pair.split('=');
-      if (k) query[decodeURIComponent(k)] = decodeURIComponent(v || '');
-    }
-  }
-  const method = req.method;
+// ─── Controllers ─────────────────────────────────────────────────────────────
 
-  // CORS preflight
-  if (method === 'OPTIONS') {
-    setCors(res);
-    res.writeHead(204);
-    return res.end();
+class WorkspaceController {
+  constructor({ getDb, closeDb, getWorkspaces, setWorkspaces, dataDir, broadcast }) {
+    this.getDb = getDb;
+    this.closeDb = closeDb;
+    this.getWorkspaces = getWorkspaces;
+    this.setWorkspaces = setWorkspaces;
+    this.dataDir = dataDir;
+    this.broadcast = broadcast;
   }
 
-  // Serve static assets (no auth — browser authenticates via WS/API headers)
-  if (method === 'GET' && !urlPath.startsWith('/api/')) {
-    const STATIC_FILES = {
-      '/': 'index.html',
-      '/index.html': 'index.html',
-      '/app.js': 'app.js',
-      '/style.css': 'style.css',
-      '/error-handler.js': 'error-handler.js',
-      '/manifest.json': 'manifest.json',
-      '/favicon.ico': 'favicon.ico',
-    };
-    const fileName = STATIC_FILES[urlPath];
-    // Also serve /icons/*, /lib/*, /frontend/*, and /config.js
-    const isIcon = urlPath.startsWith('/icons/');
-    const isLib = urlPath.startsWith('/lib/');
-    const isFrontend = urlPath.startsWith('/frontend/');
-    const isEmoji = urlPath.startsWith('/emoji/');
-    const isConfig = urlPath === '/config.js';
-    const staticPath = fileName ? path.join(__dirname, fileName)
-      : (isIcon || isLib || isFrontend || isEmoji || isConfig) ? path.join(__dirname, urlPath.slice(1))
-      : null;
-    if (staticPath && fs.existsSync(staticPath) && fs.statSync(staticPath).isFile()) {
-      const ext = path.extname(staticPath).toLowerCase();
-      const mimeMap = {
-        '.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css',
-        '.json': 'application/json', '.ico': 'image/x-icon',
-        '.png': 'image/png', '.svg': 'image/svg+xml', '.gif': 'image/gif', '.webp': 'image/webp',
-      };
-      const ct = mimeMap[ext] || 'application/octet-stream';
-      const stat = fs.statSync(staticPath);
-      res.writeHead(200, {
-        'Content-Type': ct,
-        'Content-Length': stat.size,
-        'Cache-Control': ext === '.html' ? 'no-cache' : 'public, max-age=3600',
-      });
-      return fs.createReadStream(staticPath).pipe(res);
-    }
-  }
-
-  // Serve uploaded files (no auth required — files are accessed by URL)
-  let p;
-  if ((p = matchRoute(method, urlPath, 'GET /api/uploads/:threadId/:fileId'))) {
-    return handleServeUpload(req, res, p);
-  }
-
-  // Custom emoji listing (no auth — public like static assets)
-  if (method === 'GET' && urlPath === '/api/emoji') {
-    try {
-      const db = getGlobalDb();
-      const rows = db.prepare('SELECT name, pack, url, mime_type FROM custom_emojis ORDER BY created_at DESC').all();
-      res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'public, max-age=300' });
-      return res.end(JSON.stringify(rows));
-    } catch (e) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      return res.end(JSON.stringify({ error: e.message }));
-    }
-  }
-
-  // Search slackmojis.com (scrapes HTML search since JSON API has no search)
-  if (method === 'GET' && urlPath === '/api/emoji/search') {
-    const q = query.q || '';
-    if (!q) {
-      res.writeHead(400, { 'Content-Type': 'application/json' });
-      return res.end(JSON.stringify({ error: 'Missing ?q= parameter' }));
-    }
-    try {
-      const https = await import('https');
-      const fetchUrl = `https://slackmojis.com/emojis/search?query=${encodeURIComponent(q)}`;
-      const html = await new Promise((resolve, reject) => {
-        https.default.get(fetchUrl, (resp) => {
-          let body = '';
-          resp.on('data', chunk => body += chunk);
-          resp.on('end', () => resolve(body));
-        }).on('error', reject);
-      });
-      // Parse emoji entries from HTML:
-      // <li class='emoji name' title='name'>
-      // <a ... data-emoji-id="123" data-emoji-id-name="123-name" href="/emojis/123-name/download">
-      // <img ... src="https://emojis.slackmojis.com/emojis/images/.../name.png?..." />
-      const results = [];
-      const regex = /data-emoji-id-name="([^"]+)"[^>]*href="([^"]+)"[\s\S]*?<img[^>]*src="([^"]+)"/g;
-      let match;
-      while ((match = regex.exec(html)) !== null && results.length < 50) {
-        const idName = match[1]; // e.g. "57350-sextant"
-        const downloadPath = match[2];
-        const imageUrl = match[3];
-        const name = idName.replace(/^\d+-/, '');
-        results.push({
-          name,
-          image_url: imageUrl,
-          download_url: `https://slackmojis.com${downloadPath}`,
-        });
-      }
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      return res.end(JSON.stringify(results));
-    } catch (e) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      return res.end(JSON.stringify({ error: e.message }));
-    }
-  }
-
-  // Add custom emoji (store URL in global.db)
-  if (method === 'POST' && urlPath === '/api/emoji/add') {
-    if (!checkAuth(req, res)) return;
-    try {
-      const { url, name, pack } = await parseBody(req);
-      if (!url || !name) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        return res.end(JSON.stringify({ error: 'Missing url or name' }));
-      }
-      const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '_');
-      const targetPack = pack || 'slackmojis';
-      // Determine mime type from URL extension
-      const urlLower = url.split('?')[0].toLowerCase();
-      let mimeType = 'image/png';
-      if (urlLower.endsWith('.gif')) mimeType = 'image/gif';
-      else if (urlLower.endsWith('.webp')) mimeType = 'image/webp';
-      else if (urlLower.endsWith('.jpg') || urlLower.endsWith('.jpeg')) mimeType = 'image/jpeg';
-
-      const db = getGlobalDb();
-      db.prepare('INSERT OR REPLACE INTO custom_emojis (name, pack, url, mime_type) VALUES (?, ?, ?, ?)')
-        .run(safeName, targetPack, url, mimeType);
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      return res.end(JSON.stringify({ name: safeName, pack: targetPack, url, mime_type: mimeType }));
-    } catch (e) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      return res.end(JSON.stringify({ error: e.message }));
-    }
-  }
-
-  // Delete custom emoji
-  if (method === 'DELETE' && urlPath === '/api/emoji') {
-    if (!checkAuth(req, res)) return;
-    try {
-      const { name, pack } = await parseBody(req);
-      if (!name || !pack) {
-        res.writeHead(400, { 'Content-Type': 'application/json' });
-        return res.end(JSON.stringify({ error: 'Missing name or pack' }));
-      }
-      const db = getGlobalDb();
-      db.prepare('DELETE FROM custom_emojis WHERE name = ? AND pack = ?').run(name, pack);
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      return res.end(JSON.stringify({ ok: true }));
-    } catch (e) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      return res.end(JSON.stringify({ error: e.message }));
-    }
-  }
-
-  // Auth check for all other routes
-  if (!checkAuth(req, res)) return;
-
-  try {
-    // --- File serving (absolute paths from gateway) ---
-    if (method === 'GET' && urlPath === '/api/file') {
-      return handleServeFile(req, res, query);
-    }
-
-    // --- Workspace file browser ---
-    if (method === 'GET' && urlPath === '/api/workspace') {
-      return handleWorkspaceList(req, res, query);
-    }
-    if (method === 'GET' && urlPath === '/api/workspace/file') {
-      return handleWorkspaceFileRead(req, res, query);
-    }
-    if (method === 'PUT' && urlPath === '/api/workspace/file') {
-      return await handleWorkspaceFileWrite(req, res, query);
-    }
-    if (method === 'DELETE' && urlPath === '/api/workspace/file') {
-      return handleWorkspaceFileDelete(req, res, query);
-    }
-    if (method === 'POST' && urlPath === '/api/workspace/upload') {
-      return await handleWorkspaceUpload(req, res, query);
-    }
-
-    // --- Memory (configurable backend) ---
-    if (method === 'GET' && urlPath === '/api/memory/status') {
-      return await handleMemoryStatus(req, res);
-    }
-    if (method === 'GET' && urlPath === '/api/memory/list') {
-      return await handleMemoryList(req, res, query);
-    }
-    if (method === 'GET' && urlPath === '/api/memory/search') {
-      return await handleMemorySearch(req, res, query);
-    }
-    if (method === 'GET' && urlPath === '/api/memory/files') {
-      return handleMemoryFiles(req, res, query);
-    }
-    if ((p = matchRoute(method, urlPath, 'PUT /api/memory/:id'))) {
-      return await handleMemoryUpdate(req, res, p);
-    }
-    if ((p = matchRoute(method, urlPath, 'DELETE /api/memory/:id'))) {
-      return await handleMemoryDelete(req, res, p);
-    }
-
-    // --- User settings ---
-    if (method === 'GET' && urlPath === '/api/settings') {
-      return handleGetSettings(req, res);
-    }
-    if (method === 'PUT' && urlPath === '/api/settings') {
-      return await handleSaveSettings(req, res);
-    }
-
-    // --- Speech-to-text ---
-    if (method === 'POST' && urlPath === '/api/transcribe') {
-      return await handleTranscribe(req, res);
-    }
-
-    // --- Agents ---
-    if (method === 'GET' && urlPath === '/api/agents') {
-      try {
-        const agentsDir = path.join(HOME, '.openclaw', 'agents');
-        const agents = fs.readdirSync(agentsDir, { withFileTypes: true })
-          .filter(e => e.isDirectory())
-          .map(e => e.name);
-        return send(res, 200, { agents });
-      } catch {
-        return send(res, 200, { agents: ['main'] });
-      }
-    }
-
-    // --- Workspaces ---
-    if (method === 'GET' && urlPath === '/api/workspaces') {
-      return handleGetWorkspaces(req, res);
-    }
-    if (method === 'POST' && urlPath === '/api/workspaces') {
-      return await handleCreateWorkspace(req, res);
-    }
-    if ((p = matchRoute(method, urlPath, 'PATCH /api/workspaces/:name'))) {
-      return await handleUpdateWorkspace(req, res, p);
-    }
-    if ((p = matchRoute(method, urlPath, 'DELETE /api/workspaces/:name'))) {
-      return handleDeleteWorkspace(req, res, p);
-    }
-    if (method === 'POST' && urlPath === '/api/workspaces/reorder') {
-      return await handleReorderWorkspaces(req, res);
-    }
-    if ((p = matchRoute(method, urlPath, 'POST /api/workspaces/:name/activate'))) {
-      return handleActivateWorkspace(req, res, p);
-    }
-
-    // --- Threads ---
-    if (method === 'GET' && urlPath === '/api/threads') {
-      return handleGetThreads(req, res, {}, query);
-    }
-    if (method === 'GET' && urlPath === '/api/threads/unread') {
-      return handleGetUnreadThreads(req, res);
-    }
-    if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/mark-read'))) {
-      return await handleMarkMessagesRead(req, res, p);
-    }
-    if (method === 'POST' && urlPath === '/api/threads') {
-      return await handleCreateThread(req, res);
-    }
-    // Thread-specific routes (must check more specific paths first)
-    if ((p = matchRoute(method, urlPath, 'GET /api/threads/:id/messages'))) {
-      return handleGetMessages(req, res, p, query);
-    }
-    if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/messages'))) {
-      return await handleCreateMessage(req, res, p);
-    }
-    if ((p = matchRoute(method, urlPath, 'DELETE /api/threads/:id/messages/:messageId'))) {
-      return handleDeleteMessage(req, res, p);
-    }
-    if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/context-fill'))) {
-      return handleContextFill(req, res, p);
-    }
-    if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/generate-title'))) {
-      const db = getActiveDb();
-      const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(p.id);
-      if (!thread) return sendError(res, 404, 'Thread not found');
-      // Regenerate: sets heuristic immediately (safe fallback), then fires AI upgrade
-      const activeWs = getWorkspaces().active;
-      gatewayClient.generateThreadTitle(db, p.id, activeWs);
-      return send(res, 200, { ok: true });
-    }
-    if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/upload'))) {
-      return await handleUpload(req, res, p);
-    }
-    if ((p = matchRoute(method, urlPath, 'GET /api/threads/:id/intelligence'))) {
-      return handleGetIntelligence(req, res, p);
-    }
-    if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/intelligence'))) {
-      return await handleSaveIntelligence(req, res, p);
-    }
-    if ((p = matchRoute(method, urlPath, 'GET /api/threads/:id'))) {
-      return handleGetThread(req, res, p);
-    }
-    if ((p = matchRoute(method, urlPath, 'PATCH /api/threads/:id'))) {
-      return await handleUpdateThread(req, res, p);
-    }
-    if ((p = matchRoute(method, urlPath, 'DELETE /api/threads/:id'))) {
-      return handleDeleteThread(req, res, p);
-    }
-
-    // --- Search ---
-    if (method === 'GET' && urlPath === '/api/search') {
-      return handleSearch(req, res, {}, query);
-    }
-
-    // --- Export / Import ---
-    if (method === 'GET' && urlPath === '/api/export') {
-      return handleExport(req, res);
-    }
-    if (method === 'POST' && urlPath === '/api/import') {
-      return await handleImport(req, res);
-    }
-
-    // --- Health check ---
-    if (method === 'GET' && urlPath === '/api/health') {
-      return send(res, 200, { ok: true, workspace: getWorkspaces().active, uptime: process.uptime() });
-    }
-
-    // Not found
-    sendError(res, 404, `Not found: ${method} ${urlPath}`);
-  } catch (err) {
-    console.error(`Error handling ${method} ${urlPath}:`, err);
-    if (err.message && err.message.includes('UNIQUE constraint')) {
-      sendError(res, 409, 'Conflict: ' + err.message);
-    } else {
-      sendError(res, 500, err.message || 'Internal server error');
-    }
-  }
-}
-
-// ─── Gateway WebSocket Client ───────────────────────────────────────────────
-
-class GatewayClient {
-  constructor() {
-    this.ws = null;
-    this.connected = false;
-    this.reconnectAttempts = 0;
-    this.maxReconnectDelay = 30000;
-    this.browserClients = new Map(); // Map<WebSocket, { activeWorkspace, activeThreadId }>
-    this.streamState = new Map(); // Map<sessionKey, { state, buffer, threadId }>
-    this.activityLogs = new Map(); // Map<runId, { sessionKey, steps, startTime }>
-
-    // Clean up stale activity logs every 5 minutes (runs that never completed)
-    setInterval(() => {
-      const cutoff = Date.now() - 10 * 60 * 1000;
-      for (const [runId, log] of this.activityLogs) {
-        if (log.startTime < cutoff) {
-          if (log._messageId) {
-            const db = getDb(log._parsed?.workspace);
-            if (db) {
-              db.prepare(`
-                UPDATE messages SET content = '[Response interrupted]',
-                metadata = json_remove(metadata, '$.pending')
-                WHERE id = ? AND content = ''
-              `).run(log._messageId);
-            }
-          }
-          this.activityLogs.delete(runId);
-        }
-      }
-    }, 5 * 60 * 1000);
-  }
-
-  connect() {
-    if (this.ws && (this.ws.readyState === WS.CONNECTING || this.ws.readyState === WS.OPEN)) {
-      return; // Already connecting or connected
-    }
-
-    console.log(`Connecting to gateway at ${GATEWAY_WS_URL}...`);
-    this.ws = new WS(GATEWAY_WS_URL);
-
-    this.ws.on('open', () => {
-      console.log('Gateway WebSocket connected');
-      this.reconnectAttempts = 0;
-    });
-
-    this.ws.on('message', (data) => {
-      this.handleGatewayMessage(data.toString());
-    });
-
-    this.ws.on('close', () => {
-      console.log('Gateway WebSocket closed');
-      this.connected = false;
-      this.broadcastGatewayStatus(false);
-      this.scheduleReconnect();
-    });
-
-    this.ws.on('error', (err) => {
-      console.error('Gateway WebSocket error:', err.message);
-    });
-  }
-
-  handleGatewayMessage(data) {
-    debugLogger.logFrame('GW→SRV', data);
-    let msg;
-    try {
-      msg = JSON.parse(data);
-    } catch (e) {
-      console.error('Invalid JSON from gateway:', data);
-      return;
-    }
-
-    // Handle connect.challenge (handshake)
-    if (msg.type === 'event' && msg.event === 'connect.challenge') {
-      console.log('Received connect.challenge, sending auth...');
-      const nonce = msg.payload?.nonce || '';
-      const identityPath = path.join(DATA_DIR, 'device-identity.json');
-      const identity = _loadOrCreateDeviceIdentity(identityPath);
-      const device = _buildDeviceAuth(identity, {
-        clientId: 'gateway-client', clientMode: 'backend', role: 'operator',
-        scopes: ['operator.read', 'operator.write', 'operator.admin'], token: AUTH_TOKEN, nonce
-      });
-      this.ws.send(JSON.stringify({
-        type: 'req',
-        id: 'gw-connect-1',
-        method: 'connect',
-        params: {
-          minProtocol: 3,
-          maxProtocol: 3,
-          client: { id: 'gateway-client', version: '0.1.0', platform: 'node', mode: 'backend' },
-          role: 'operator',
-          scopes: ['operator.read', 'operator.write', 'operator.admin'],
-          device,
-          auth: { token: AUTH_TOKEN },
-          caps: ['tool-events']
-        }
-      }));
-      return;
-    }
-
-    // Handle connect response (hello-ok)
-    if (msg.type === 'res' && msg.payload?.type === 'hello-ok') {
-      console.log('Gateway handshake complete');
-      this.connected = true;
-      this.broadcastGatewayStatus(true);
-    }
-
-    // Forward all messages to browser clients
-    this.broadcastToBrowsers(data);
-
-    // Process chat events for persistence
-    if (msg.type === 'event' && msg.event === 'chat' && msg.payload) {
-      this.handleChatEvent(msg.payload);
-    }
-
-    // Process agent events for activity log
-    if (msg.type === 'event' && msg.event === 'agent' && msg.payload) {
-      this.handleAgentEvent(msg.payload);
-    }
-  }
-
-  handleChatEvent(params) {
-    const { sessionKey, state, message, seq } = params;
-
-    // Update streaming state
-    if (state === 'delta') {
-      const parsed = parseSessionKey(sessionKey);
-      if (parsed) {
-        const existing = this.streamState.get(sessionKey) || { buffer: '', threadId: parsed.threadId, state: 'streaming' };
-        const deltaText = extractContent(message);
-        existing.buffer += deltaText;
-        this.streamState.set(sessionKey, existing);
-      }
-      return;
-    }
-
-    // Clear stream state on final/aborted/error
-    if (state === 'final' || state === 'aborted' || state === 'error') {
-      this.streamState.delete(sessionKey);
-    }
-
-    // Intercept title generation responses (final, error, or aborted)
-    if (sessionKey && sessionKey.includes('__clawchats_title_')) {
-      if (state === 'final') {
-        const content = extractContent(message);
-        if (content && this.handleTitleResponse(sessionKey, content)) return;
-      } else if (state === 'error' || state === 'aborted') {
-        // Clean up pending entry by substring match — heuristic title stays
-        if (this._pendingTitleGens) {
-          for (const key of this._pendingTitleGens.keys()) {
-            if (sessionKey === key || sessionKey.includes(key)) { this._pendingTitleGens.delete(key); break; }
-          }
-        }
-        return;
-      }
-    }
-
-    // Save assistant messages on final
-    if (state === 'final') {
-      this.saveAssistantMessage(sessionKey, message, seq);
-    }
-
-    // Save error markers
-    if (state === 'error') {
-      this.saveErrorMarker(sessionKey, message);
-    }
-  }
-
-  saveAssistantMessage(sessionKey, message, seq) {
-    const parsed = parseSessionKey(sessionKey);
-    if (!parsed) return;
-
-    const ws = getWorkspaces();
-    if (!ws.workspaces[parsed.workspace]) {
-      console.log(`Ignoring response for deleted workspace: ${parsed.workspace}`);
-      return;
-    }
-
-    const db = getDb(parsed.workspace);
-
-    const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(parsed.threadId);
-    if (!thread) {
-      console.log(`Ignoring response for deleted thread: ${parsed.threadId}`);
-      return;
-    }
-
-    const content = extractContent(message);
-    if (!content || !content.trim()) {
-      console.log(`Skipping empty assistant response for thread ${parsed.threadId}`);
-      return;
-    }
-
-    const now = Date.now();
-
-    // Check for pending activity message
-    const pendingMsg = db.prepare(`
-      SELECT id, metadata FROM messages
-      WHERE thread_id = ? AND role = 'assistant'
-      AND json_extract(metadata, '$.pending') = 1
-      ORDER BY timestamp DESC LIMIT 1
-    `).get(parsed.threadId);
-
-    let messageId;
-
-    if (pendingMsg) {
-      // Merge final content into existing activity row
-      const metadata = pendingMsg.metadata ? JSON.parse(pendingMsg.metadata) : {};
-      delete metadata.pending;
-
-      // Clean up: remove last assistant narration (it's the final reply text)
-      if (metadata.activityLog) {
-        const lastAssistantIdx = metadata.activityLog.findLastIndex(s => s.type === 'assistant');
-        if (lastAssistantIdx >= 0) metadata.activityLog.splice(lastAssistantIdx, 1);
-        metadata.activitySummary = this.generateActivitySummary(metadata.activityLog);
-      }
-
-      db.prepare('UPDATE messages SET content = ?, metadata = ?, timestamp = ? WHERE id = ?')
-        .run(content, JSON.stringify(metadata), now, pendingMsg.id);
-
-      messageId = pendingMsg.id;
-    } else {
-      // No pending activity — normal INSERT (simple responses, no tools)
-      messageId = seq != null ? `gw-${parsed.threadId}-${seq}` : `gw-${parsed.threadId}-${now}`;
-      db.prepare(`
-        INSERT INTO messages (id, thread_id, role, content, status, timestamp, created_at)
-        VALUES (?, ?, 'assistant', ?, 'sent', ?, ?)
-        ON CONFLICT(id) DO UPDATE SET content = excluded.content, timestamp = excluded.timestamp
-      `).run(messageId, parsed.threadId, content, now, now);
-    }
-
-    // Thread timestamp + unreads + broadcast (same for both paths)
-    try {
-      db.prepare('UPDATE threads SET updated_at = ? WHERE id = ?').run(now, parsed.threadId);
-      db.prepare('INSERT OR IGNORE INTO unread_messages (thread_id, message_id, created_at) VALUES (?, ?, ?)').run(parsed.threadId, messageId, now);
-      syncThreadUnreadCount(db, parsed.threadId);
-
-      const threadInfo = db.prepare('SELECT title FROM threads WHERE id = ?').get(parsed.threadId);
-      const unreadCount = db.prepare('SELECT COUNT(*) as c FROM unread_messages WHERE thread_id = ?').get(parsed.threadId).c;
-      const preview = content.length > 120 ? content.substring(0, 120) + '...' : content;
-
-      this.broadcastToBrowsers(JSON.stringify({
-        type: 'clawchats',
-        event: 'message-saved',
-        threadId: parsed.threadId,
-        workspace: parsed.workspace,
-        messageId,
-        timestamp: now,
-        title: threadInfo?.title || 'Chat',
-        preview,
-        unreadCount
-      }));
-
-      const workspaceUnreadTotal = db.prepare('SELECT COALESCE(SUM(unread_count), 0) as total FROM threads').get().total;
-      this.broadcastToBrowsers(JSON.stringify({
-        type: 'clawchats',
-        event: 'unread-update',
-        workspace: parsed.workspace,
-        threadId: parsed.threadId,
-        messageId,
-        action: 'new',
-        unreadCount,
-        workspaceUnreadTotal,
-        title: threadInfo?.title || 'Chat',
-        preview,
-        timestamp: now
-      }));
-
-      console.log(`Saved assistant message to ${parsed.workspace}/${parsed.threadId} (${pendingMsg ? 'merged into pending' : 'seq: ' + seq})`);
-
-      // Auto-generate AI title upgrade after first assistant response
-      // Heuristic was already set on user message save; this fires the AI upgrade
-      const currentTitle = db.prepare('SELECT title FROM threads WHERE id = ?').get(parsed.threadId)?.title;
-      const msgCount = db.prepare('SELECT COUNT(*) as c FROM messages WHERE thread_id = ?').get(parsed.threadId).c;
-      if (msgCount === 2 || currentTitle === 'New chat') {
-        this.generateThreadTitle(db, parsed.threadId, parsed.workspace, true);
-      }
-    } catch (e) {
-      console.error(`Failed to save assistant message:`, e.message);
-    }
-  }
-
-  saveErrorMarker(sessionKey, message) {
-    const parsed = parseSessionKey(sessionKey);
-    if (!parsed) return;
-
-    const ws = getWorkspaces();
-    if (!ws.workspaces[parsed.workspace]) return;
-
-    const db = getDb(parsed.workspace);
-    const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(parsed.threadId);
-    if (!thread) return;
-
-    const errorText = message?.error || message?.content || 'Unknown error';
-    const content = `[error] ${errorText}`;
-    const now = Date.now();
-    const messageId = `gw-error-${parsed.threadId}-${now}`;
-
-    try {
-      db.prepare(
-        'INSERT INTO messages (id, thread_id, role, content, status, metadata, timestamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)'
-      ).run(messageId, parsed.threadId, 'system', content, 'sent', '{"transient":true}', now, now);
-
-      console.log(`Saved error marker for ${parsed.workspace}/${parsed.threadId}`);
-    } catch (e) {
-      console.error(`Failed to save error marker:`, e.message);
-    }
-  }
-
-  /**
-   * Generate a title for a thread. Optionally sets a heuristic title immediately,
-   * then fires an async AI title upgrade via the gateway.
-   * @param {boolean} skipHeuristic - If true, skip heuristic step (already set on user message save)
-   */
-  generateThreadTitle(db, threadId, workspace, skipHeuristic = false) {
-    const thread = db.prepare('SELECT title FROM threads WHERE id = ?').get(threadId);
-    if (!thread) return;
-
-    // Skip if AI title gen already in progress for this thread
-    const titleKey = `__clawchats_title_${threadId}`;
-    if (this._pendingTitleGens?.has(titleKey)) return;
-
-    // Get first user message for heuristic title
-    const firstUserMsg = db.prepare(
-      "SELECT content FROM messages WHERE thread_id = ? AND role = 'user' ORDER BY created_at ASC LIMIT 1"
-    ).get(threadId);
-    if (!firstUserMsg?.content) return;
-
-    // Step 1: Heuristic title (immediate) — skip if already set on user message save
-    if (!skipHeuristic) {
-      const heuristic = firstUserMsg.content.replace(/\n.*/s, '').slice(0, 40).trim()
-        + (firstUserMsg.content.length > 40 ? '...' : '');
-      db.prepare('UPDATE threads SET title = ? WHERE id = ?').run(heuristic, threadId);
-
-      this.broadcastToBrowsers(JSON.stringify({
-        type: 'clawchats',
-        event: 'thread-title-updated',
-        threadId,
-        workspace,
-        title: heuristic
-      }));
-    }
-
-    // Step 2: AI title upgrade (async, best-effort)
-    const messages = db.prepare(
-      'SELECT role, content FROM messages WHERE thread_id = ? ORDER BY created_at ASC LIMIT 6'
-    ).all(threadId);
-
-    // Need at least 2 messages (user + assistant) for meaningful AI title
-    if (messages.length < 2) return;
-
-    const conversation = messages.map(m => {
-      const role = m.role === 'user' ? 'User' : 'Assistant';
-      const content = m.content.length > 300 ? m.content.slice(0, 300) + '...' : m.content;
-      return `${role}: ${content}`;
-    }).join('\n\n');
-
-    const prompt = `Based on this conversation, generate a concise 3-5 word title. Return ONLY the title text, no quotes, no explanation:\n\n${conversation}\n\nTitle:`;
-
-    const reqId = `title-${threadId}-${Date.now()}`;
-    if (!this._pendingTitleGens) this._pendingTitleGens = new Map();
-    this._pendingTitleGens.set(titleKey, { threadId, workspace, reqId });
-
-    // Timeout cleanup — prevent unbounded map growth if gateway never responds
-    setTimeout(() => {
-      if (this._pendingTitleGens?.has(titleKey)) {
-        this._pendingTitleGens.delete(titleKey);
-        console.log(`Title gen timeout for ${threadId} — keeping heuristic title`);
-      }
-    }, 30000);
-
-    this.sendToGateway(JSON.stringify({
-      type: 'req',
-      id: reqId,
-      method: 'chat.send',
-      params: {
-        sessionKey: titleKey,
-        message: prompt,
-        deliver: false,
-        idempotencyKey: reqId
-      }
-    }));
-  }
-
-  /**
-   * Handle AI title response from gateway.
-   * Returns true if the event was consumed (was a title gen response).
-   */
-  handleTitleResponse(sessionKey, content) {
-    if (!this._pendingTitleGens) return false;
-    // Gateway may prefix sessionKey (e.g. agent:main:__clawchats_title_xxx)
-    // Find the matching pending entry by substring
-    let matchKey = null, pending = null;
-    for (const [key, val] of this._pendingTitleGens) {
-      if (sessionKey === key || sessionKey.includes(key)) {
-        matchKey = key;
-        pending = val;
-        break;
-      }
-    }
-    if (!pending) return false;
-
-    this._pendingTitleGens.delete(matchKey);
-
-    let title = content.trim()
-      .replace(/^["']|["']$/g, '')
-      .replace(/^Title:\s*/i, '')
-      .replace(/\n.*/s, '')
-      .trim();
-
-    if (title.length > 50) title = title.substring(0, 47) + '...';
-    if (title.length === 0 || title.length >= 100) return true; // bad response, keep heuristic
-
-    const db = getDb(pending.workspace);
-    db.prepare('UPDATE threads SET title = ? WHERE id = ?').run(title, pending.threadId);
-
-    this.broadcastToBrowsers(JSON.stringify({
-      type: 'clawchats',
-      event: 'thread-title-updated',
-      threadId: pending.threadId,
-      workspace: pending.workspace,
-      title
-    }));
-
-    console.log(`AI title generated for ${pending.threadId}: "${title}"`);
-    return true;
-  }
-
-  handleAgentEvent(payload) {
-    const { runId, stream, data, sessionKey } = payload;
-    if (!runId) return;
-
-    // Initialize log if needed
-    if (!this.activityLogs.has(runId)) {
-      this.activityLogs.set(runId, { sessionKey, steps: [], startTime: Date.now() });
-    }
-    const log = this.activityLogs.get(runId);
-
-    if (stream === 'assistant') {
-      // Capture intermediate text turns (narration between tool calls)
-      const text = data?.text || '';
-      if (text) {
-        let currentSegment = log._currentAssistantSegment;
-        if (!currentSegment || currentSegment._sealed) {
-          currentSegment = {
-            type: 'assistant',
-            timestamp: Date.now(),
-            text: text,
-            _sealed: false
-          };
-          log._currentAssistantSegment = currentSegment;
-          log.steps.push(currentSegment);
-        } else {
-          currentSegment.text = text;
-        }
-      }
-      // Don't broadcast on every assistant delta — too noisy
-      return;
-    }
-
-    if (stream === 'thinking') {
-      const thinkingText = data?.text || '';
-      let thinkingStep = log.steps.find(s => s.type === 'thinking');
-      if (thinkingStep) {
-        thinkingStep.text = thinkingText;
-      } else {
-        log.steps.push({
-          type: 'thinking',
-          timestamp: Date.now(),
-          text: thinkingText
-        });
-      }
-      // Always write to DB; throttle broadcasts to every 300ms
-      this._writeActivityToDb(runId, log);
-      const now = Date.now();
-      if (!log._lastThinkingBroadcast || now - log._lastThinkingBroadcast >= 300) {
-        log._lastThinkingBroadcast = now;
-        this._broadcastActivityUpdate(runId, log);
-      }
-    }
-
-    if (stream === 'tool') {
-      // Seal any current assistant text segment (narration before this tool call)
-      if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) {
-        log._currentAssistantSegment._sealed = true;
-      }
-
-      const args = data?.args;
-      const argsMeta = args ? (args.command || args.path || args.query || args.url || Object.values(args).find(v => typeof v === 'string') || '') : '';
-      const step = {
-        type: 'tool',
-        timestamp: Date.now(),
-        name: data?.name || 'unknown',
-        phase: data?.phase || 'start',
-        toolCallId: data?.toolCallId,
-        meta: data?.meta || (argsMeta ? String(argsMeta) : undefined),
-        isError: data?.isError || false
-      };
-
-      // On result phase, update the existing start step or add new
-      if (data?.phase === 'result') {
-        const existing = log.steps.findLast(s => s.toolCallId === data.toolCallId && (s.phase === 'start' || s.phase === 'running'));
-        if (existing) {
-          existing.phase = 'done';
-          existing.resultMeta = data?.meta;
-          existing.isError = data?.isError || false;
-          existing.durationMs = Date.now() - existing.timestamp;
-        } else {
-          step.phase = 'done';
-          log.steps.push(step);
-        }
-      } else if (data?.phase === 'update') {
-        const existing = log.steps.findLast(s => s.toolCallId === data.toolCallId);
-        if (existing) {
-          if (data?.meta) existing.resultMeta = data.meta;
-          if (data?.isError) existing.isError = true;
-          existing.phase = 'running';
-        }
-      } else {
-        log.steps.push(step);
-      }
-
-      this._writeActivityToDb(runId, log);
-      this._broadcastActivityUpdate(runId, log);
-    }
-
-    if (stream === 'lifecycle') {
-      if (data?.phase === 'end' || data?.phase === 'error') {
-        // Seal any remaining assistant segment
-        if (log._currentAssistantSegment && !log._currentAssistantSegment._sealed) {
-          log._currentAssistantSegment._sealed = true;
-        }
-        // Remove the final assistant segment — that's the actual response, not narration
-        const lastAssistantIdx = log.steps.findLastIndex(s => s.type === 'assistant');
-        if (lastAssistantIdx >= 0) {
-          log.steps.splice(lastAssistantIdx, 1);
-        }
-
-        // Write final state to DB, then clean up
-        this._writeActivityToDb(runId, log);
-        this.activityLogs.delete(runId);
-        return;
-      }
-    }
-  }
-
-  _writeActivityToDb(runId, log) {
-    writeActivityToDb(getDb, this.broadcastToBrowsers.bind(this), runId, log);
-  }
-
-  _broadcastActivityUpdate(runId, log) {
-    const parsed = log._parsed;
-    if (!parsed || !log._messageId) return;
-
-    const cleanSteps = log.steps.map(s => { const c = {...s}; delete c._sealed; return c; });
-
-    this.broadcastToBrowsers(JSON.stringify({
-      type: 'clawchats',
-      event: 'activity-updated',
-      workspace: parsed.workspace,
-      threadId: parsed.threadId,
-      messageId: log._messageId,
-      activityLog: cleanSteps,
-      activitySummary: this.generateActivitySummary(log.steps)
-    }));
-  }
-
-  generateActivitySummary(steps) {
-    return generateActivitySummary(steps);
-  }
-
-  broadcastToBrowsers(data) {
-    debugLogger.logFrame('SRV→BR', data);
-    for (const client of this.browserClients.keys()) {
-      if (client.readyState === WS.OPEN) {
-        client.send(data);
-      }
-    }
-  }
-
-  broadcastGatewayStatus(connected) {
-    const msg = JSON.stringify({
-      type: 'clawchats',
-      event: 'gateway-status',
-      connected
-    });
-    this.broadcastToBrowsers(msg);
-  }
-
-  sendToGateway(data) {
-    debugLogger.logFrame('SRV→GW', data);
-    if (this.ws && this.ws.readyState === WS.OPEN) {
-      this.ws.send(data);
-    } else {
-      console.error('Cannot send to gateway: not connected');
-    }
-  }
-
-  scheduleReconnect() {
-    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), this.maxReconnectDelay);
-    this.reconnectAttempts++;
-    console.log(`Reconnecting to gateway in ${delay}ms (attempt ${this.reconnectAttempts})...`);
-    setTimeout(() => this.connect(), delay);
-  }
-
-  addBrowserClient(ws) {
-    this.browserClients.set(ws, { activeWorkspace: null, activeThreadId: null });
-
-    // Send current gateway status
-    if (ws.readyState === WS.OPEN) {
-      ws.send(JSON.stringify({
-        type: 'clawchats',
-        event: 'gateway-status',
-        connected: this.connected
-      }));
-
-      // Send stream-sync with current streaming states
-      const streams = [];
-      for (const [sessionKey, state] of this.streamState.entries()) {
-        if (state.state === 'streaming') {
-          streams.push({ sessionKey, threadId: state.threadId, buffer: state.buffer });
-        }
-      }
-      if (streams.length > 0) {
-        ws.send(JSON.stringify({
-          type: 'clawchats',
-          event: 'stream-sync',
-          streams
-        }));
-      }
-    }
-  }
-
-  removeBrowserClient(ws) {
-    this.browserClients.delete(ws);
-  }
-
-  setActiveThread(ws, workspace, threadId) {
-    const client = ws ? this.browserClients.get(ws) : null;
-    if (client) {
-      client.activeWorkspace = workspace;
-      client.activeThreadId = threadId;
-    }
-
-    // Auto-clear unreads: opening a thread = reading it (read receipt)
-    if (workspace && threadId) {
-      try {
-        const wsData = getWorkspaces();
-        if (!wsData.workspaces[workspace]) return;
-
-        const db = getDb(workspace);
-        const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(threadId);
-        if (!thread) return;
-
-        // Delete all unread entries for this thread
-        const deleted = db.prepare('DELETE FROM unread_messages WHERE thread_id = ?').run(threadId);
-        if (deleted.changes > 0) {
-          syncThreadUnreadCount(db, threadId);
-
-          // Broadcast unread-update clear to ALL browser clients
-          const workspaceUnreadTotal = db.prepare('SELECT COALESCE(SUM(unread_count), 0) as total FROM threads').get().total;
-          this.broadcastToBrowsers(JSON.stringify({
-            type: 'clawchats',
-            event: 'unread-update',
-            workspace,
-            threadId,
-            action: 'clear',
-            unreadCount: 0,
-            workspaceUnreadTotal,
-            timestamp: Date.now()
-          }));
-        }
-      } catch (e) {
-        console.error('Failed to auto-clear unreads on active-thread:', e.message);
-      }
-    }
-  }
-}
-
-// Helper: Recount unread_messages and sync threads.unread_count
-function syncThreadUnreadCount(db, threadId) {
-  const count = db.prepare('SELECT COUNT(*) as c FROM unread_messages WHERE thread_id = ?').get(threadId).c;
-  db.prepare('UPDATE threads SET unread_count = ? WHERE id = ?').run(count, threadId);
-  return count;
-}
-
-// Helper: Parse session key
-function parseSessionKey(sessionKey) {
-  if (!sessionKey) return null;
-  const match = sessionKey.match(/^agent:([^:]+):([^:]+):chat:([^:]+)$/);
-  if (!match) return null; // Non-ClawChats keys — silently ignore
-  return { agent: match[1], workspace: match[2], threadId: match[3] };
-}
-
-// Helper: Extract content from message
-function extractContent(message) {
-  if (!message) return '';
-  if (typeof message.content === 'string') return message.content;
-  if (Array.isArray(message.content)) {
-    return message.content
-      .filter(part => part.type === 'text')
-      .map(part => part.text)
-      .join('');
-  }
-  return '';
-}
-
-// ─── Sentinel filtering helpers ───────────────────────────────────────────────
-// Mirrors logic from OpenClaw's tokens-C27XM9Ox.js so we can filter NO_REPLY /
-// HEARTBEAT_OK tokens before they reach the browser — including partial leaks
-// during streaming (e.g. "NO_" appearing mid-stream before the full token is
-// assembled). See GitHub issue #96.
-
-// Returns true if text is exactly the sentinel (with optional surrounding whitespace).
-function isSilentReplyExact(text, token = 'NO_REPLY') {
-  if (!text) return false;
-  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  return new RegExp(`^\\s*${escaped}\\s*$`).test(text);
-}
-
-// Returns true if text could be the beginning of the sentinel token —
-// i.e. it is a strict uppercase-only prefix of the token.
-// Example: "NO" and "NO_" and "NO_REPLY" all return true for token="NO_REPLY".
-function isSilentReplyPrefix(text, token = 'NO_REPLY') {
-  if (!text) return false;
-  const trimmed = text.trimStart();
-  if (!trimmed) return false;
-  if (trimmed !== trimmed.toUpperCase()) return false;   // must be ALL CAPS
-  const normalized = trimmed.toUpperCase();
-  if (normalized.length < 2) return false;
-  if (/[^A-Z_]/.test(normalized)) return false;          // only letters + underscore
-  const tokenUpper = token.toUpperCase();
-  if (!tokenUpper.startsWith(normalized)) return false;  // must be a prefix
-  if (normalized.includes('_')) return true;             // past the first word — unambiguous
-  // Single word without underscore: only allow "NO" for NO_REPLY (avoids false-positives
-  // on other short all-caps words like "HI", "OK", etc.)
-  return tokenUpper === 'NO_REPLY' && normalized === 'NO';
-}
-
-// Strip a trailing sentinel token from mixed-content text (e.g. "answer NO_REPLY" → "answer").
-function stripTrailingSentinel(text, token = 'NO_REPLY') {
-  if (!text) return text;
-  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  return text.replace(new RegExp(`(?:^|\\s+|\\*+)${escaped}\\s*$`), '').trim();
-}
-
-// Strip internal <final> / </final> tags that occasionally leak from the model.
-function stripFinalTags(text) {
-  if (!text) return text;
-  return text.replace(/<\s*\/?\s*final\s*>/gi, '');
-}
-
-// Apply all content sanitization steps before saving to DB.
-function sanitizeAssistantContent(text) {
-  if (!text) return text;
-  let out = stripFinalTags(text);
-  out = out.replace(/^(?:[ \t]*\r?\n)+/, ''); // strip leading blank lines
-  if (out.includes('NO_REPLY'))    out = stripTrailingSentinel(out, 'NO_REPLY');
-  if (out.includes('HEARTBEAT_OK')) out = stripTrailingSentinel(out, 'HEARTBEAT_OK');
-  return out;
-}
-
-// ─── Shared activity log helpers ─────────────────────────────────────────────
-// Pure functions extracted from GatewayClient / _GatewayClient so both classes
-// share a single implementation. Pass the workspace-scoped DB getter and a
-// bound broadcastToBrowsers fn as arguments.
-
-function generateActivitySummary(steps) {
-  const toolSteps = steps.filter(s => s.type === 'tool' && s.phase !== 'result' && s.phase !== 'update');
-  const hasThinking = steps.some(s => s.type === 'thinking' && s.text);
-  const hasNarration = steps.some(s => s.type === 'assistant' && s.text?.trim());
-  if (toolSteps.length === 0 && !hasThinking && !hasNarration) return null;
-  if (toolSteps.length === 0 && hasThinking) return 'Reasoned through the problem';
-  if (toolSteps.length === 0 && hasNarration) return 'Processed in multiple steps';
-
-  const counts = {};
-  for (const s of toolSteps) {
-    const name = s.name || 'unknown';
-    counts[name] = (counts[name] || 0) + 1;
-  }
-
-  const parts = [];
-  const toolNames = {
-    'web_search': 'searched the web',
-    'web_fetch': 'fetched web pages',
-    'Read': 'read files',
-    'read': 'read files',
-    'Write': 'wrote files',
-    'write': 'wrote files',
-    'Edit': 'edited files',
-    'edit': 'edited files',
-    'exec': 'ran commands',
-    'Bash': 'ran commands',
-    'browser': 'browsed the web',
-    'memory_search': 'searched memory',
-    'memory_store': 'saved to memory',
-    'image': 'analyzed images',
-    'message': 'sent messages',
-    'sessions_spawn': 'spawned sub-agents',
-    'cron': 'managed cron jobs',
-    'Grep': 'searched code',
-    'grep': 'searched code',
-    'Glob': 'found files',
-    'glob': 'found files'
-  };
-
-  for (const [name, count] of Object.entries(counts)) {
-    const friendly = toolNames[name];
-    if (friendly) {
-      parts.push(count > 1 ? `${friendly} (${count}×)` : friendly);
-    } else {
-      parts.push(count > 1 ? `used ${name} (${count}×)` : `used ${name}`);
-    }
-  }
-
-  if (parts.length === 0) return null;
-  if (parts.length === 1) return parts[0].charAt(0).toUpperCase() + parts[0].slice(1);
-  const last = parts.pop();
-  return (parts.join(', ') + ' and ' + last).replace(/^./, c => c.toUpperCase());
-}
-
-function writeActivityToDb(getDbFn, broadcastFn, runId, log) {
-  if (!log._parsed) {
-    log._parsed = parseSessionKey(log.sessionKey);
-  }
-  const parsed = log._parsed;
-  if (!parsed) return;
-
-  const db = getDbFn(parsed.workspace);
-  if (!db) return;
-
-  const cleanSteps = log.steps.map(s => { const c = {...s}; delete c._sealed; return c; });
-  const summary = generateActivitySummary(log.steps);
-  const now = Date.now();
-
-  if (!log._messageId) {
-    const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(parsed.threadId);
-    if (!thread) return;
-
-    const messageId = `gw-activity-${runId}`;
-    const metadata = { activityLog: cleanSteps, activitySummary: summary, pending: true };
-
-    try {
-      db.prepare(`
-        INSERT OR IGNORE INTO messages (id, thread_id, role, content, status, metadata, timestamp, created_at)
-        VALUES (?, ?, 'assistant', '', 'sent', ?, ?, ?)
-      `).run(messageId, parsed.threadId, JSON.stringify(metadata), now, now);
-
-      log._messageId = messageId;
-
-      broadcastFn(JSON.stringify({
-        type: 'clawchats',
-        event: 'message-saved',
-        threadId: parsed.threadId,
-        workspace: parsed.workspace,
-        messageId,
-        timestamp: now
-      }));
-    } catch (err) {
-      console.error(`[activity] Failed to write activity ${messageId}:`, err.message);
-    }
-  } else {
-    const existing = db.prepare('SELECT metadata FROM messages WHERE id = ?').get(log._messageId);
-    const metadata = existing?.metadata ? JSON.parse(existing.metadata) : {};
-    metadata.activityLog = cleanSteps;
-    metadata.activitySummary = summary;
-    metadata.pending = true;
-
-    db.prepare('UPDATE messages SET metadata = ? WHERE id = ?')
-      .run(JSON.stringify(metadata), log._messageId);
-  }
-}
-
-const gatewayClient = new GatewayClient();
-
-// ─── createApp Factory ───────────────────────────────────────────────────────
-// Returns an isolated instance of the app state + handlers.
-// Used by the plugin (signaling/index.js) to embed ClawChats logic without
-// spinning up a standalone HTTP server.
-
-export function createApp(config = {}) {
-  // ── Config-dependent constants ─────────────────────────────────────────────
-  const _DATA_DIR = config.dataDir || path.join(__dirname, 'data');
-  const _UPLOADS_DIR = config.uploadsDir || path.join(__dirname, 'uploads');
-  const _WORKSPACES_FILE = path.join(_DATA_DIR, 'workspaces.json');
-  const _SETTINGS_FILE = path.join(_DATA_DIR, 'settings.json');
-  const _INTELLIGENCE_DIR = path.join(_DATA_DIR, 'intelligence');
-
-  let _AUTH_TOKEN = config.authToken !== undefined
-    ? config.authToken
-    : (process.env.CLAWCHATS_AUTH_TOKEN || process.env.SHELLCHAT_AUTH_TOKEN || parseConfigField('authToken') || '');
-
-  // Separate token for gateway WS auth (falls back to _AUTH_TOKEN for direct mode)
-  const _GATEWAY_TOKEN = config.gatewayToken !== undefined
-    ? config.gatewayToken
-    : _AUTH_TOKEN;
-
-  const _GATEWAY_WS_URL = config.gatewayUrl || discoverGatewayWsUrl();
-
-  // ── Mutable singleton state ────────────────────────────────────────────────
-  const _dbCache = new Map();
-  let _workspacesConfig = null;
-  const _debugLogger = new DebugLogger(_DATA_DIR);
-
-  const _MEMORY_CONFIG = discoverMemoryConfig();
-  const _memoryProvider = createMemoryProvider(_MEMORY_CONFIG);
-  _memoryProvider.init().catch(err => console.error('[createApp] Memory provider init error:', err.message));
-
-  const _MEMORY_FILES_DIR = path.join(_MEMORY_CONFIG.workspaceDir, 'memory');
-
-  // ── Workspace helpers ──────────────────────────────────────────────────────
-  function _loadWorkspaces() {
-    try {
-      return JSON.parse(fs.readFileSync(_WORKSPACES_FILE, 'utf8'));
-    } catch {
-      const initial = {
-        active: 'default',
-        workspaces: {
-          default: { name: 'default', label: 'Default', createdAt: Date.now() }
-        }
-      };
-      fs.writeFileSync(_WORKSPACES_FILE, JSON.stringify(initial, null, 2));
-      return initial;
-    }
-  }
-
-  function _saveWorkspaces(data) {
-    fs.writeFileSync(_WORKSPACES_FILE, JSON.stringify(data, null, 2));
-  }
-
-  function _getWorkspaces() {
-    if (!_workspacesConfig) _workspacesConfig = _loadWorkspaces();
-    return _workspacesConfig;
-  }
-
-  function _setWorkspaces(data) {
-    _workspacesConfig = data;
-    _saveWorkspaces(data);
-  }
-
-  // ── Database helpers ───────────────────────────────────────────────────────
-  function _getDb(workspaceName) {
-    if (_dbCache.has(workspaceName)) return _dbCache.get(workspaceName);
-    const dbPath = path.join(_DATA_DIR, `${workspaceName}.db`);
-    const db = new Database(dbPath);
-    db.pragma('journal_mode = WAL');
-    db.pragma('foreign_keys = ON');
-    migrate(db);
-    _dbCache.set(workspaceName, db);
-    return db;
-  }
-
-  function _getActiveDb() {
-    return _requestDbStore.getStore() || _getDb(_getWorkspaces().active);
-  }
-
-  function _closeDb(workspaceName) {
-    const db = _dbCache.get(workspaceName);
-    if (db) { db.close(); _dbCache.delete(workspaceName); }
-  }
-
-  function _closeAllDbs() {
-    for (const [, db] of _dbCache) db.close();
-    _dbCache.clear();
-  }
-
-  function _ensureDirs() {
-    fs.mkdirSync(_DATA_DIR, { recursive: true });
-    fs.mkdirSync(_UPLOADS_DIR, { recursive: true });
-  }
-
-  // ── Auth (closes over _AUTH_TOKEN) ─────────────────────────────────────────
-  function _checkAuth(req, res) {
-    if (!_AUTH_TOKEN) return true;
-    const auth = req.headers.authorization;
-    if (!auth || !auth.startsWith('Bearer ')) {
-      sendError(res, 401, 'Missing or invalid Authorization header');
-      return false;
-    }
-    const token = auth.slice(7);
-    if (token !== _AUTH_TOKEN) {
-      sendError(res, 401, 'Invalid auth token');
-      return false;
-    }
-    return true;
-  }
-
-  // ── Route handlers (all close over _getDb, _getActiveDb, _getWorkspaces, etc.) ──
-
-  function _handleGetSettings(req, res) {
-    try {
-      const data = fs.existsSync(_SETTINGS_FILE)
-        ? JSON.parse(fs.readFileSync(_SETTINGS_FILE, 'utf8'))
-        : {};
-      return send(res, 200, data);
-    } catch { return send(res, 200, {}); }
-  }
-
-  async function _handleSaveSettings(req, res) {
-    const body = await parseBody(req);
-    try {
-      const existing = fs.existsSync(_SETTINGS_FILE)
-        ? JSON.parse(fs.readFileSync(_SETTINGS_FILE, 'utf8'))
-        : {};
-      const merged = { ...existing, ...body };
-      fs.writeFileSync(_SETTINGS_FILE, JSON.stringify(merged, null, 2));
-      return send(res, 200, merged);
-    } catch (err) { return send(res, 500, { error: err.message }); }
-  }
-
-  function _handleGetWorkspaces(req, res) {
-    const ws = _getWorkspaces();
+  getAll(req, res) {
+    const ws = this.getWorkspaces();
     const sorted = Object.values(ws.workspaces).sort((a, b) => (a.order ?? 999) - (b.order ?? 999));
     for (const workspace of sorted) {
       try {
-        const db = _getDb(workspace.name);
-        const result = db.prepare('SELECT COALESCE(SUM(unread_count), 0) as total FROM threads').get();
-        workspace.unread_count = result.total;
+        const db = this.getDb(workspace.name);
+        workspace.unread_count = db.prepare('SELECT COALESCE(SUM(unread_count), 0) as total FROM threads').get().total;
       } catch { workspace.unread_count = 0; }
     }
     send(res, 200, { active: ws.active, workspaces: sorted });
   }
 
-  async function _handleCreateWorkspace(req, res) {
+  async create(req, res) {
     const body = await parseBody(req);
     const { name, label } = body;
-    if (!name || !/^[a-z0-9-]{1,32}$/.test(name)) {
-      return sendError(res, 400, 'Name must be [a-z0-9-], 1-32 chars');
-    }
-    const ws = _getWorkspaces();
+    if (!name || !/^[a-z0-9-]{1,32}$/.test(name)) return sendError(res, 400, 'Name must be [a-z0-9-], 1-32 chars');
+    const ws = this.getWorkspaces();
     if (ws.workspaces[name]) return sendError(res, 409, 'Workspace already exists');
     let agent = 'main';
     try { agent = validateAgent(body.agent || 'main'); } catch { agent = 'main'; }
     const workspace = { name, label: label || name, color: body.color || null, icon: body.icon || null, agent, createdAt: Date.now() };
     ws.workspaces[name] = workspace;
-    _setWorkspaces(ws);
-    _getDb(name);
+    this.setWorkspaces(ws);
+    this.getDb(name);
     send(res, 201, { workspace });
   }
 
-  async function _handleUpdateWorkspace(req, res, params) {
+  async update(req, res, params) {
     const body = await parseBody(req);
-    const ws = _getWorkspaces();
+    const ws = this.getWorkspaces();
     if (!ws.workspaces[params.name]) return sendError(res, 404, 'Workspace not found');
     if (body.label !== undefined) ws.workspaces[params.name].label = body.label;
     if (body.color !== undefined) ws.workspaces[params.name].color = body.color;
@@ -3665,73 +1430,67 @@ export function createApp(config = {}) {
       try { newAgent = validateAgent(body.agent); } catch (e) { return sendError(res, 400, e.message); }
       const oldAgent = ws.workspaces[params.name].agent || 'main';
       if (newAgent !== oldAgent) {
-        const db = _getDb(params.name);
-        const threads = db.prepare(
-          `SELECT id, session_key FROM threads WHERE session_key LIKE ?`
-        ).all(`agent:${oldAgent}:${params.name}:chat:%`);
-        db.prepare(`
-          UPDATE threads
-          SET session_key = replace(
-            session_key,
-            'agent:' || ? || ':' || ? || ':chat:',
-            'agent:' || ? || ':' || ? || ':chat:'
-          )
-          WHERE session_key LIKE 'agent:' || ? || ':' || ? || ':chat:%'
-        `).run(oldAgent, params.name, newAgent, params.name, oldAgent, params.name);
+        const db = this.getDb(params.name);
+        const threads = db.prepare(`SELECT id, session_key FROM threads WHERE session_key LIKE ?`).all(`agent:${oldAgent}:${params.name}:chat:%`);
+        db.prepare(`UPDATE threads SET session_key = replace(session_key, 'agent:' || ? || ':' || ? || ':chat:', 'agent:' || ? || ':' || ? || ':chat:') WHERE session_key LIKE 'agent:' || ? || ':' || ? || ':chat:%'`).run(oldAgent, params.name, newAgent, params.name, oldAgent, params.name);
         for (const t of threads) cleanGatewaySession(t.session_key);
         ws.workspaces[params.name].agent = newAgent;
         migratedThreads = threads.length;
-        _gatewayClient.broadcastToBrowsers(JSON.stringify({
-          type: 'clawchats',
-          event: 'workspace-agent-changed',
-          workspace: params.name,
-          agent: newAgent
-        }));
+        this.broadcast(JSON.stringify({ type: 'clawchats', event: 'workspace-agent-changed', workspace: params.name, agent: newAgent }));
       }
     }
-    _setWorkspaces(ws);
+    this.setWorkspaces(ws);
     send(res, 200, { workspace: ws.workspaces[params.name], migratedThreads });
   }
 
-  function _handleDeleteWorkspace(req, res, params) {
-    const ws = _getWorkspaces();
+  delete(req, res, params) {
+    const ws = this.getWorkspaces();
     if (!ws.workspaces[params.name]) return sendError(res, 404, 'Workspace not found');
     if (Object.keys(ws.workspaces).length <= 1) return sendError(res, 400, 'Cannot delete the only workspace');
-    _closeDb(params.name);
-    const dbPath = path.join(_DATA_DIR, `${params.name}.db`);
+    this.closeDb(params.name);
+    const dbPath = path.join(this.dataDir, `${params.name}.db`);
     try { fs.unlinkSync(dbPath); } catch { /* ok */ }
     try { fs.unlinkSync(dbPath + '-wal'); } catch { /* ok */ }
     try { fs.unlinkSync(dbPath + '-shm'); } catch { /* ok */ }
-    const wsAgentForDelete = ws.workspaces[params.name]?.agent || 'main';
-    const cleaned = cleanGatewaySessionsByPrefix(`agent:${wsAgentForDelete}:${params.name}:chat:`);
+    const wsAgent = ws.workspaces[params.name]?.agent || 'main';
+    const cleaned = cleanGatewaySessionsByPrefix(`agent:${wsAgent}:${params.name}:chat:`);
     if (cleaned > 0) console.log(`Cleaned ${cleaned} gateway sessions for workspace: ${params.name}`);
     delete ws.workspaces[params.name];
     if (ws.active === params.name) ws.active = Object.keys(ws.workspaces)[0] || null;
-    _setWorkspaces(ws);
+    this.setWorkspaces(ws);
     send(res, 200, { ok: true });
   }
 
-  async function _handleReorderWorkspaces(req, res) {
+  async reorder(req, res) {
     const body = await parseBody(req);
     const { order } = body;
     if (!Array.isArray(order)) return sendError(res, 400, 'order must be an array of workspace names');
-    const ws = _getWorkspaces();
+    const ws = this.getWorkspaces();
     order.forEach((name, i) => { if (ws.workspaces[name]) ws.workspaces[name].order = i; });
-    _setWorkspaces(ws);
+    this.setWorkspaces(ws);
     send(res, 200, { ok: true, workspaces: Object.values(ws.workspaces) });
   }
 
-  function _handleActivateWorkspace(req, res, params) {
-    const ws = _getWorkspaces();
+  activate(req, res, params) {
+    const ws = this.getWorkspaces();
     if (!ws.workspaces[params.name]) return sendError(res, 404, 'Workspace not found');
     ws.active = params.name;
-    _setWorkspaces(ws);
-    _getDb(params.name);
+    this.setWorkspaces(ws);
+    this.getDb(params.name);
     send(res, 200, { ok: true, workspace: ws.workspaces[params.name] });
   }
+}
+
+class ThreadController {
+  constructor({ getActiveDb, getWorkspaces, uploadsDir, broadcast }) {
+    this.getActiveDb = getActiveDb;
+    this.getWorkspaces = getWorkspaces;
+    this.uploadsDir = uploadsDir;
+    this.broadcast = broadcast;
+  }
 
-  function _handleGetThreads(req, res, params, query) {
-    const db = _getActiveDb();
+  getAll(req, res, params, query) {
+    const db = this.getActiveDb();
     const page = parseInt(query.page || '1', 10);
     const limit = Math.min(parseInt(query.limit || '50', 10), 200);
     const offset = (page - 1) * limit;
@@ -3739,16 +1498,12 @@ export function createApp(config = {}) {
     let threads, total;
     if (search) {
       try {
-        const ftsQuery = `SELECT DISTINCT m.thread_id FROM messages m JOIN messages_fts ON messages_fts.rowid = m.rowid WHERE messages_fts MATCH ?`;
-        const matchingIds = db.prepare(ftsQuery).all(search).map(r => r.thread_id);
+        const matchingIds = db.prepare(`SELECT DISTINCT m.thread_id FROM messages m JOIN messages_fts ON messages_fts.rowid = m.rowid WHERE messages_fts MATCH ?`).all(search).map(r => r.thread_id);
         if (matchingIds.length === 0) return send(res, 200, { threads: [], total: 0, page });
-        const placeholders = matchingIds.map(() => '?').join(',');
-        total = db.prepare(`SELECT COUNT(*) as c FROM threads WHERE id IN (${placeholders})`).get(...matchingIds).c;
-        threads = db.prepare(`SELECT * FROM threads WHERE id IN (${placeholders}) ORDER BY pinned DESC, sort_order DESC, updated_at DESC LIMIT ? OFFSET ?`).all(...matchingIds, limit, offset);
-      } catch (ftsErr) {
-        console.warn('[DB] FTS thread search failed, returning empty results:', ftsErr.message);
-        return send(res, 200, { threads: [], total: 0, page });
-      }
+        const ph = matchingIds.map(() => '?').join(',');
+        total = db.prepare(`SELECT COUNT(*) as c FROM threads WHERE id IN (${ph})`).get(...matchingIds).c;
+        threads = db.prepare(`SELECT * FROM threads WHERE id IN (${ph}) ORDER BY pinned DESC, sort_order DESC, updated_at DESC LIMIT ? OFFSET ?`).all(...matchingIds, limit, offset);
+      } catch { return send(res, 200, { threads: [], total: 0, page }); }
     } else {
       total = db.prepare('SELECT COUNT(*) as c FROM threads').get().c;
       threads = db.prepare('SELECT * FROM threads ORDER BY pinned DESC, sort_order DESC, updated_at DESC LIMIT ? OFFSET ?').all(limit, offset);
@@ -3756,118 +1511,102 @@ export function createApp(config = {}) {
     send(res, 200, { threads, total, page });
   }
 
-  function _handleGetUnreadThreads(req, res) {
-    const db = _getActiveDb();
-    const threads = db.prepare(`
-      SELECT t.id, t.title, t.unread_count, m.content as lastMessage
-      FROM threads t
-      LEFT JOIN messages m ON m.thread_id = t.id
-      WHERE t.unread_count > 0
-      AND m.timestamp = (SELECT MAX(timestamp) FROM messages WHERE thread_id = t.id)
-      ORDER BY t.updated_at DESC
-    `).all();
+  getUnread(req, res) {
+    const db = this.getActiveDb();
+    const threads = db.prepare(`SELECT t.id, t.title, t.unread_count, m.content as lastMessage FROM threads t LEFT JOIN messages m ON m.thread_id = t.id WHERE t.unread_count > 0 AND m.timestamp = (SELECT MAX(timestamp) FROM messages WHERE thread_id = t.id) ORDER BY t.updated_at DESC`).all();
     for (const thread of threads) {
-      const rows = db.prepare('SELECT message_id FROM unread_messages WHERE thread_id = ?').all(thread.id);
-      thread.unreadMessageIds = rows.map(r => r.message_id);
+      thread.unreadMessageIds = db.prepare('SELECT message_id FROM unread_messages WHERE thread_id = ?').all(thread.id).map(r => r.message_id);
     }
     send(res, 200, { threads });
   }
 
-  async function _handleMarkMessagesRead(req, res, params) {
+  async markRead(req, res, params) {
     const body = await parseBody(req);
-    const db = _getActiveDb();
-    const threadId = params.id;
-    const messageIds = body.messageIds;
-    if (!Array.isArray(messageIds) || messageIds.length === 0) {
-      return send(res, 400, { error: 'messageIds array required' });
-    }
-    const placeholders = messageIds.map(() => '?').join(',');
-    db.prepare(`DELETE FROM unread_messages WHERE thread_id = ? AND message_id IN (${placeholders})`).run(threadId, ...messageIds);
-    const remaining = syncThreadUnreadCount(db, threadId);
-    const workspace = _getWorkspaces().active;
-    _gatewayClient.broadcastToBrowsers(JSON.stringify({
-      type: 'clawchats', event: 'unread-update', workspace, threadId,
-      action: 'read', messageIds, unreadCount: remaining, timestamp: Date.now()
-    }));
+    const db = this.getActiveDb();
+    const { messageIds } = body;
+    if (!Array.isArray(messageIds) || messageIds.length === 0) return send(res, 400, { error: 'messageIds array required' });
+    const ph = messageIds.map(() => '?').join(',');
+    db.prepare(`DELETE FROM unread_messages WHERE thread_id = ? AND message_id IN (${ph})`).run(params.id, ...messageIds);
+    const remaining = syncThreadUnreadCount(db, params.id);
+    const workspace = this.getWorkspaces().active;
+    this.broadcast(JSON.stringify({ type: 'clawchats', event: 'unread-update', workspace, threadId: params.id, action: 'read', messageIds, unreadCount: remaining, timestamp: Date.now() }));
     send(res, 200, { unread_count: remaining });
   }
 
-  async function _handleCreateThread(req, res) {
+  async create(req, res) {
     const body = await parseBody(req);
-    const db = _getActiveDb();
-    const ws = _getWorkspaces();
+    const db = this.getActiveDb();
+    const ws = this.getWorkspaces();
     const id = body.id || uuid();
     const now = Date.now();
-    const workspaceAgent = ws.workspaces[ws.active]?.agent || 'main';
-    const sessionKey = `agent:${workspaceAgent}:${ws.active}:chat:${id}`;
+    const agent = ws.workspaces[ws.active]?.agent || 'main';
+    const sessionKey = `agent:${agent}:${ws.active}:chat:${id}`;
     try {
       db.prepare('INSERT INTO threads (id, session_key, title, created_at, updated_at) VALUES (?, ?, ?, ?, ?)').run(id, sessionKey, 'New chat', now, now);
     } catch (e) {
       if (e.message.includes('UNIQUE constraint')) return sendError(res, 409, 'Thread already exists');
       throw e;
     }
-    const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(id);
-    send(res, 201, { thread });
+    send(res, 201, { thread: db.prepare('SELECT * FROM threads WHERE id = ?').get(id) });
   }
 
-  function _handleGetThread(req, res, params) {
-    const db = _getActiveDb();
-    const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(params.id);
+  get(req, res, params) {
+    const thread = this.getActiveDb().prepare('SELECT * FROM threads WHERE id = ?').get(params.id);
     if (!thread) return sendError(res, 404, 'Thread not found');
     send(res, 200, { thread });
   }
 
-  async function _handleUpdateThread(req, res, params) {
+  async update(req, res, params) {
     const body = await parseBody(req);
-    const db = _getActiveDb();
-    const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(params.id);
-    if (!thread) return sendError(res, 404, 'Thread not found');
+    const db = this.getActiveDb();
+    if (!db.prepare('SELECT id FROM threads WHERE id = ?').get(params.id)) return sendError(res, 404, 'Thread not found');
     const fields = [], values = [];
-    if (body.title !== undefined) { fields.push('title = ?'); values.push(body.title); }
+    for (const [col, val] of [['title', body.title], ['model', body.model], ['last_session_id', body.last_session_id], ['unread_count', body.unread_count]]) {
+      if (val !== undefined) { fields.push(`${col} = ?`); values.push(val); }
+    }
     if (body.pinned !== undefined) { fields.push('pinned = ?'); values.push(body.pinned ? 1 : 0); }
     if (body.pin_order !== undefined) { fields.push('pin_order = ?'); values.push(body.pin_order); }
     if (body.sort_order !== undefined) { fields.push('sort_order = ?'); values.push(body.sort_order); }
-    if (body.model !== undefined) { fields.push('model = ?'); values.push(body.model); }
-    if (body.last_session_id !== undefined) { fields.push('last_session_id = ?'); values.push(body.last_session_id); }
-    if (body.unread_count !== undefined) { fields.push('unread_count = ?'); values.push(body.unread_count); }
     if (fields.length > 0) {
-      fields.push('updated_at = ?'); values.push(Date.now()); values.push(params.id);
+      fields.push('updated_at = ?'); values.push(Date.now(), params.id);
       db.prepare(`UPDATE threads SET ${fields.join(', ')} WHERE id = ?`).run(...values);
     }
-    const updated = db.prepare('SELECT * FROM threads WHERE id = ?').get(params.id);
-    send(res, 200, { thread: updated });
+    send(res, 200, { thread: db.prepare('SELECT * FROM threads WHERE id = ?').get(params.id) });
   }
 
-  function _handleDeleteThread(req, res, params) {
-    const db = _getActiveDb();
+  delete(req, res, params) {
+    const db = this.getActiveDb();
     const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(params.id);
     if (!thread) return sendError(res, 404, 'Thread not found');
     db.prepare('DELETE FROM threads WHERE id = ?').run(params.id);
     let sessionIdToDelete = thread.last_session_id;
-    const tAgentMatch = (thread.session_key || '').match(/^agent:([^:]+):/);
-    const tSessionsDir = getSessionsDirForAgent(tAgentMatch?.[1]);
+    const agentMatch = (thread.session_key || '').match(/^agent:([^:]+):/);
+    const sessionsDir = getSessionsDirForAgent(agentMatch?.[1]);
     if (!sessionIdToDelete) {
       try {
-        const raw = fs.readFileSync(path.join(tSessionsDir, 'sessions.json'), 'utf8');
-        const store = JSON.parse(raw);
-        const entry = store[thread.session_key];
-        if (entry?.sessionId) sessionIdToDelete = entry.sessionId;
+        const store = JSON.parse(fs.readFileSync(path.join(sessionsDir, 'sessions.json'), 'utf8'));
+        sessionIdToDelete = store[thread.session_key]?.sessionId;
       } catch { /* ok */ }
     }
     cleanGatewaySession(thread.session_key);
     if (sessionIdToDelete) {
-      const jsonlPath = path.join(tSessionsDir, `${sessionIdToDelete}.jsonl`);
-      try { fs.unlinkSync(jsonlPath); } catch { /* ok */ }
+      try { fs.unlinkSync(path.join(sessionsDir, `${sessionIdToDelete}.jsonl`)); } catch { /* ok */ }
     }
-    const uploadDir = path.join(_UPLOADS_DIR, params.id);
-    try { fs.rmSync(uploadDir, { recursive: true }); } catch { /* ok */ }
+    try { fs.rmSync(path.join(this.uploadsDir, params.id), { recursive: true }); } catch { /* ok */ }
     send(res, 200, { ok: true });
   }
+}
 
-  function _handleGetMessages(req, res, params, query) {
-    const db = _getActiveDb();
-    const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(params.id);
-    if (!thread) return sendError(res, 404, 'Thread not found');
+class MessageController {
+  constructor({ getActiveDb, getWorkspaces, broadcast }) {
+    this.getActiveDb = getActiveDb;
+    this.getWorkspaces = getWorkspaces;
+    this.broadcast = broadcast;
+  }
+
+  getAll(req, res, params, query) {
+    const db = this.getActiveDb();
+    if (!db.prepare('SELECT id FROM threads WHERE id = ?').get(params.id)) return sendError(res, 404, 'Thread not found');
     const limit = Math.min(parseInt(query.limit || '100', 10), 500);
     const before = query.before ? parseInt(query.before, 10) : null;
     const after = query.after ? parseInt(query.after, 10) : null;
@@ -3875,302 +1614,484 @@ export function createApp(config = {}) {
     const sqlParams = [params.id];
     if (before) { sql += ' AND timestamp < ?'; sqlParams.push(before); }
     if (after) { sql += ' AND timestamp > ?'; sqlParams.push(after); }
-    const countSql = sql.replace('SELECT *', 'SELECT COUNT(*) as c');
-    const total = db.prepare(countSql).get(...sqlParams).c;
-    sql += ' ORDER BY timestamp DESC LIMIT ?';
-    sqlParams.push(limit + 1);
-    const rows = db.prepare(sql).all(...sqlParams);
+    const total = db.prepare(sql.replace('SELECT *', 'SELECT COUNT(*) as c')).get(...sqlParams).c;
+    const rows = db.prepare(sql + ' ORDER BY timestamp DESC LIMIT ?').all(...sqlParams, limit + 1);
     const hasMore = rows.length > limit;
     const messages = rows.slice(0, limit).reverse();
-    for (const m of messages) {
-      if (m.metadata) { try { m.metadata = JSON.parse(m.metadata); } catch { /* ok */ } }
-    }
+    for (const m of messages) { if (m.metadata) { try { m.metadata = JSON.parse(m.metadata); } catch { /* ok */ } } }
     send(res, 200, { messages, hasMore });
   }
 
-  async function _handleCreateMessage(req, res, params) {
+  async create(req, res, params) {
     const body = await parseBody(req);
-    const db = _getActiveDb();
-    const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(params.id);
-    if (!thread) return sendError(res, 404, 'Thread not found');
-    if (!body.id || !body.role || body.content === undefined || !body.timestamp) {
-      return sendError(res, 400, 'Required: id, role, content, timestamp');
-    }
+    const db = this.getActiveDb();
+    if (!db.prepare('SELECT id FROM threads WHERE id = ?').get(params.id)) return sendError(res, 404, 'Thread not found');
+    if (!body.id || !body.role || body.content === undefined || !body.timestamp) return sendError(res, 400, 'Required: id, role, content, timestamp');
     const metadata = body.metadata ? JSON.stringify(body.metadata) : null;
     const existing = db.prepare('SELECT id, status, metadata FROM messages WHERE id = ?').get(body.id);
     if (existing) {
-      const newStatus = body.status || existing.status;
-      const statusChanged = body.status && body.status !== existing.status;
-      if (statusChanged || metadata) {
-        // Only overwrite metadata if new metadata is provided; otherwise preserve existing
-        const finalMetadata = metadata || existing.metadata || null;
-        db.prepare('UPDATE messages SET status = ?, content = ?, metadata = ? WHERE id = ?').run(newStatus, body.content, finalMetadata, body.id);
+      if (body.status && body.status !== existing.status) {
+        db.prepare('UPDATE messages SET status = ?, content = ?, metadata = ? WHERE id = ?').run(body.status, body.content, metadata || existing.metadata, body.id);
       }
     } else {
       db.prepare('INSERT INTO messages (id, thread_id, role, content, status, metadata, seq, timestamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)').run(body.id, params.id, body.role, body.content, body.status || 'sent', metadata, body.seq || null, body.timestamp, Date.now());
       db.prepare('UPDATE threads SET updated_at = ? WHERE id = ?').run(Date.now(), params.id);
-
-      // Heuristic title on first user message (mimics Claude/ChatGPT — title appears immediately on send)
       if (body.role === 'user' && body.content) {
         const threadInfo = db.prepare('SELECT title FROM threads WHERE id = ?').get(params.id);
         if (threadInfo?.title === 'New chat') {
-          const heuristic = body.content.replace(/\n.*/s, '').slice(0, 40).trim()
-            + (body.content.length > 40 ? '...' : '');
-          if (heuristic) {
-            db.prepare('UPDATE threads SET title = ? WHERE id = ?').run(heuristic, params.id);
-            const activeWs = _getWorkspaces().active;
-            _gatewayClient.broadcastToBrowsers(JSON.stringify({
-              type: 'clawchats',
-              event: 'thread-title-updated',
-              threadId: params.id,
-              workspace: activeWs,
-              title: heuristic
-            }));
+          const title = body.content.replace(/\n.*/s, '').slice(0, 40).trim() + (body.content.length > 40 ? '...' : '');
+          if (title) {
+            db.prepare('UPDATE threads SET title = ? WHERE id = ?').run(title, params.id);
+            this.broadcast(JSON.stringify({ type: 'clawchats', event: 'thread-title-updated', threadId: params.id, workspace: this.getWorkspaces().active, title }));
           }
         }
       }
     }
     const message = db.prepare('SELECT * FROM messages WHERE id = ?').get(body.id);
-    if (message && message.metadata) { try { message.metadata = JSON.parse(message.metadata); } catch { /* ok */ } }
+    if (message?.metadata) { try { message.metadata = JSON.parse(message.metadata); } catch { /* ok */ } }
     send(res, existing ? 200 : 201, { message });
   }
 
-  function _handleDeleteMessage(req, res, params) {
-    const db = _getActiveDb();
-    const msg = db.prepare('SELECT id FROM messages WHERE id = ? AND thread_id = ?').get(params.messageId, params.id);
-    if (!msg) return sendError(res, 404, 'Message not found');
+  delete(req, res, params) {
+    const db = this.getActiveDb();
+    if (!db.prepare('SELECT id FROM messages WHERE id = ? AND thread_id = ?').get(params.messageId, params.id)) return sendError(res, 404, 'Message not found');
     db.prepare('DELETE FROM messages WHERE id = ?').run(params.messageId);
     send(res, 200, { ok: true });
   }
 
-  function _handleContextFill(req, res, params) {
-    const db = _getActiveDb();
+  contextFill(req, res, params) {
+    const db = this.getActiveDb();
     const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(params.id);
     if (!thread) return sendError(res, 404, 'Thread not found');
     const { preamble, method } = buildContextPreamble(db, params.id, thread.last_session_id, thread.session_key);
     send(res, 200, { preamble, method });
   }
 
-  function _handleSearch(req, res, params, query) {
-    const db = _getActiveDb();
+  search(req, res, params, query) {
+    const db = this.getActiveDb();
     const q = query.q || '';
     if (!q) return send(res, 200, { results: [], total: 0 });
     const page = parseInt(query.page || '1', 10);
     const limit = Math.min(parseInt(query.limit || '20', 10), 100);
     const offset = (page - 1) * limit;
     try {
-      const results = db.prepare(`
-        SELECT m.id as messageId, m.thread_id as threadId, t.title as threadTitle, m.role,
-          snippet(messages_fts, 0, '<mark>', '</mark>', '...', 40) as content, m.timestamp
-        FROM messages_fts JOIN messages m ON messages_fts.rowid = m.rowid JOIN threads t ON m.thread_id = t.id
-        WHERE messages_fts MATCH ? ORDER BY rank LIMIT ? OFFSET ?
-      `).all(q, limit, offset);
-      const totalRow = db.prepare(`SELECT COUNT(*) as c FROM messages_fts WHERE messages_fts MATCH ?`).get(q);
-      send(res, 200, { results, total: totalRow.c });
-    } catch (ftsErr) {
-      console.warn('[DB] FTS message search failed, returning empty results:', ftsErr.message);
-      send(res, 200, { results: [], total: 0 });
-    }
+      const results = db.prepare(`SELECT m.id as messageId, m.thread_id as threadId, t.title as threadTitle, m.role, snippet(messages_fts, 0, '<mark>', '</mark>', '...', 40) as content, m.timestamp FROM messages_fts JOIN messages m ON messages_fts.rowid = m.rowid JOIN threads t ON m.thread_id = t.id WHERE messages_fts MATCH ? ORDER BY rank LIMIT ? OFFSET ?`).all(q, limit, offset);
+      const total = db.prepare(`SELECT COUNT(*) as c FROM messages_fts WHERE messages_fts MATCH ?`).get(q).c;
+      send(res, 200, { results, total });
+    } catch { send(res, 200, { results: [], total: 0 }); }
   }
 
-  function _handleExport(req, res) {
-    const db = _getActiveDb();
-    const ws = _getWorkspaces();
+  export(req, res) {
+    const db = this.getActiveDb();
+    const ws = this.getWorkspaces();
     const threads = db.prepare('SELECT * FROM threads ORDER BY updated_at DESC').all();
-    const data = {
+    send(res, 200, {
       workspace: ws.active, exportedAt: Date.now(),
       threads: threads.map(t => {
         const messages = db.prepare('SELECT * FROM messages WHERE thread_id = ? ORDER BY timestamp ASC').all(t.id);
         for (const m of messages) { if (m.metadata) { try { m.metadata = JSON.parse(m.metadata); } catch { /* ok */ } } }
         return { ...t, messages };
       }),
-    };
-    send(res, 200, data);
+    });
   }
 
-  async function _handleImport(req, res) {
+  async import(req, res) {
     const body = await parseBody(req);
-    const db = _getActiveDb();
-    const ws = _getWorkspaces();
+    const db = this.getActiveDb();
+    const ws = this.getWorkspaces();
     if (!body.threads || !Array.isArray(body.threads)) return sendError(res, 400, 'Expected { threads: [...] }');
     let threadsImported = 0, messagesImported = 0;
     const insertThread = db.prepare('INSERT OR IGNORE INTO threads (id, session_key, title, pinned, pin_order, model, last_session_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)');
     const insertMsg = db.prepare('INSERT OR IGNORE INTO messages (id, thread_id, role, content, status, metadata, seq, timestamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)');
-    const importAll = db.transaction(() => {
+    db.transaction(() => {
       for (const t of body.threads) {
         if (!t.id) continue;
-        // TODO: per-project agent — import uses agent:main for now
         const sessionKey = t.session_key || `agent:main:${ws.active}:chat:${t.id}`;
-        const result = insertThread.run(t.id, sessionKey, t.title || 'Imported chat', t.pinned || 0, t.pin_order || 0, t.model || null, t.last_session_id || null, t.created_at || Date.now(), t.updated_at || Date.now());
-        if (result.changes > 0) threadsImported++;
+        if (insertThread.run(t.id, sessionKey, t.title || 'Imported chat', t.pinned || 0, t.pin_order || 0, t.model || null, t.last_session_id || null, t.created_at || Date.now(), t.updated_at || Date.now()).changes > 0) threadsImported++;
         for (const m of (t.messages || [])) {
           if (!m.id || !m.role) continue;
-          const metadata = m.metadata ? (typeof m.metadata === 'string' ? m.metadata : JSON.stringify(m.metadata)) : null;
-          const r = insertMsg.run(m.id, t.id, m.role, m.content || '', m.status || 'sent', metadata, m.seq || null, m.timestamp || Date.now(), m.created_at || Date.now());
-          if (r.changes > 0) messagesImported++;
+          const meta = m.metadata ? (typeof m.metadata === 'string' ? m.metadata : JSON.stringify(m.metadata)) : null;
+          if (insertMsg.run(m.id, t.id, m.role, m.content || '', m.status || 'sent', meta, m.seq || null, m.timestamp || Date.now(), m.created_at || Date.now()).changes > 0) messagesImported++;
         }
       }
-    });
-    importAll();
+    })();
     send(res, 200, { ok: true, threadsImported, messagesImported });
   }
+}
+
+class FileController {
+  constructor({ getActiveDb, getWorkspaces, uploadsDir, intelligenceDir }) {
+    this.getActiveDb = getActiveDb;
+    this.getWorkspaces = getWorkspaces;
+    this.uploadsDir = uploadsDir;
+    this.intelligenceDir = intelligenceDir;
+  }
 
-  async function _handleUpload(req, res, params) {
-    const db = _getActiveDb();
-    const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(params.id);
-    if (!thread) return sendError(res, 404, 'Thread not found');
+  async upload(req, res, params) {
+    const db = this.getActiveDb();
+    if (!db.prepare('SELECT id FROM threads WHERE id = ?').get(params.id)) return sendError(res, 404, 'Thread not found');
     const files = await parseMultipart(req);
-    const threadUploadDir = path.join(_UPLOADS_DIR, params.id);
-    fs.mkdirSync(threadUploadDir, { recursive: true });
+    const dir = path.join(this.uploadsDir, params.id);
+    fs.mkdirSync(dir, { recursive: true });
     const savedFiles = [];
     for (const file of files) {
       const fileId = uuid();
       const ext = path.extname(file.filename) || '';
-      const savedName = fileId + ext;
-      const filePath = path.join(threadUploadDir, savedName);
-      fs.writeFileSync(filePath, file.data);
+      const savedPath = path.join(dir, fileId + ext);
+      fs.writeFileSync(savedPath, file.data);
       savedFiles.push({ id: fileId, filename: file.filename, path: `/api/uploads/${params.id}/${fileId}${ext}`, mimeType: file.mimeType, size: file.data.length });
     }
     send(res, 200, { files: savedFiles });
   }
 
-  function _handleServeUpload(req, res, params) {
-    const filePath = path.join(_UPLOADS_DIR, params.threadId, params.fileId);
-    let resolved = filePath;
+  serveUpload(req, res, params) {
+    const base = path.join(this.uploadsDir, params.threadId, params.fileId);
+    let resolved = base;
     if (!fs.existsSync(resolved)) {
-      const dir = path.join(_UPLOADS_DIR, params.threadId);
       try {
-        const entries = fs.readdirSync(dir);
-        const match = entries.find(e => e.startsWith(params.fileId.replace(/\.[^.]+$/, '')));
-        if (match) resolved = path.join(dir, match);
-      } catch { /* dir not found */ }
+        const match = fs.readdirSync(path.join(this.uploadsDir, params.threadId)).find(e => e.startsWith(params.fileId.replace(/\.[^.]+$/, '')));
+        if (match) resolved = path.join(this.uploadsDir, params.threadId, match);
+      } catch { /* ok */ }
     }
     if (!fs.existsSync(resolved)) return sendError(res, 404, 'File not found');
-    const ext = path.extname(resolved).toLowerCase();
-    const mimeTypes = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml', '.pdf': 'application/pdf', '.txt': 'text/plain', '.json': 'application/json' };
-    const contentType = mimeTypes[ext] || 'application/octet-stream';
+    const MIME = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp', '.pdf': 'application/pdf', '.txt': 'text/plain', '.json': 'application/json' };
     const stat = fs.statSync(resolved);
-    res.writeHead(200, { 'Content-Type': contentType, 'Content-Length': stat.size, 'Cache-Control': 'public, max-age=86400', 'Access-Control-Allow-Origin': '*' });
+    res.writeHead(200, { 'Content-Type': MIME[path.extname(resolved).toLowerCase()] || 'application/octet-stream', 'Content-Length': stat.size, 'Cache-Control': 'public, max-age=86400', 'Access-Control-Allow-Origin': '*' });
     fs.createReadStream(resolved).pipe(res);
   }
 
-  function _getIntelligencePath(threadId) {
-    const workspace = _getWorkspaces().active;
-    return path.join(_INTELLIGENCE_DIR, workspace, `${threadId}.json`);
+  _intelligencePath(threadId) {
+    return path.join(this.intelligenceDir, this.getWorkspaces().active, `${threadId}.json`);
   }
 
-  function _handleGetIntelligence(req, res, params) {
-    const filePath = _getIntelligencePath(params.id);
+  getIntelligence(req, res, params) {
+    const filePath = this._intelligencePath(params.id);
     if (!fs.existsSync(filePath)) return send(res, 200, { versions: [], currentVersion: -1 });
     try { return send(res, 200, JSON.parse(fs.readFileSync(filePath, 'utf8'))); }
     catch { return send(res, 200, { versions: [], currentVersion: -1 }); }
   }
 
-  async function _handleSaveIntelligence(req, res, params) {
+  async saveIntelligence(req, res, params) {
     const body = await parseBody(req);
-    const filePath = _getIntelligencePath(params.id);
+    const filePath = this._intelligencePath(params.id);
     fs.mkdirSync(path.dirname(filePath), { recursive: true });
     const data = { versions: body.versions || [], currentVersion: body.currentVersion ?? -1, updatedAt: Date.now() };
     fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
-    return send(res, 200, data);
+    send(res, 200, data);
+  }
+}
+
+class MemoryController {
+  constructor({ memoryProvider, memoryFilesDir, memoryConfig }) {
+    this.provider = memoryProvider;
+    this.filesDir = memoryFilesDir;
+    this.config = memoryConfig;
   }
 
-  async function _handleMemoryList(req, res, query) {
+  async list(req, res, query) {
     const limit = Math.min(parseInt(query.limit) || 20, 100);
-    try {
-      const result = await _memoryProvider.list(limit, query.offset || null);
-      send(res, 200, result);
-    } catch (err) { send(res, 502, { error: `Failed to reach ${_memoryProvider.name}`, detail: err.message }); }
+    try { send(res, 200, await this.provider.list(limit, query.offset || null)); }
+    catch (err) { send(res, 502, { error: `Failed to reach ${this.provider.name}`, detail: err.message }); }
   }
 
-  async function _handleMemorySearch(req, res, query) {
+  async search(req, res, query) {
     const q = (query.query || '').toLowerCase().trim();
     if (!q) return send(res, 400, { error: 'Missing query parameter' });
-    try {
-      const result = await _memoryProvider.search(q);
-      send(res, 200, result);
-    } catch (err) { send(res, 502, { error: `Failed to reach ${_memoryProvider.name}`, detail: err.message }); }
+    try { send(res, 200, await this.provider.search(q)); }
+    catch (err) { send(res, 502, { error: `Failed to reach ${this.provider.name}`, detail: err.message }); }
   }
 
-  function _handleMemoryFiles(req, res, query) {
+  files(req, res, query) {
     const q = (query.query || '').toLowerCase().trim();
-    // Use _MEMORY_FILES_DIR scoped to this factory instance
-    const memories = _parseMemoryFiles();
+    const memories = this._parseFiles();
     const filtered = q ? memories.filter(m => m.data.toLowerCase().includes(q) || m.title.toLowerCase().includes(q)) : memories;
     filtered.sort((a, b) => (b.createdAt || '').localeCompare(a.createdAt || ''));
     send(res, 200, { memories: filtered });
   }
 
-  function _parseMemoryFiles() {
+  _parseFiles() {
     const memories = [];
-    let files;
-    try { files = fs.readdirSync(_MEMORY_FILES_DIR); } catch { return memories; }
-    for (const file of files) {
-      if (!file.endsWith('.md')) continue;
-      const filePath = path.join(_MEMORY_FILES_DIR, file);
-      let stat;
-      try { stat = fs.statSync(filePath); } catch { continue; }
-      if (!stat.isFile()) continue;
-      const content = fs.readFileSync(filePath, 'utf8');
-      const basename = file.replace(/\.md$/, '');
-      const dateMatch = basename.match(/^(\d{4}-\d{2}-\d{2})/);
-      const fileDate = dateMatch ? dateMatch[1] : null;
-      const sections = content.split(/^(?=## )/m);
-      for (const section of sections) {
-        const trimmed = section.trim();
-        if (!trimmed) continue;
-        const headingMatch = trimmed.match(/^##\s+(.+)/);
-        const heading = headingMatch ? headingMatch[1].trim() : null;
-        const body = headingMatch ? trimmed.slice(trimmed.indexOf('\n') + 1).trim() : trimmed;
-        if (!heading && body.match(/^#\s+/) && body.split('\n').length <= 2) continue;
-        const title = heading || basename;
-        const id = `file:${basename}:${title}`;
-        memories.push({ id, source: 'file', file: basename, title, data: heading ? `**${title}**\n${body}` : body, createdAt: fileDate ? `${fileDate}T00:00:00Z` : stat.mtime.toISOString() });
-      }
-    }
-    try {
-      for (const entry of fs.readdirSync(_MEMORY_FILES_DIR)) {
-        const subdir = path.join(_MEMORY_FILES_DIR, entry);
-        if (!fs.statSync(subdir).isDirectory()) continue;
-        for (const file of fs.readdirSync(subdir)) {
-          if (!file.endsWith('.md')) continue;
-          const filePath = path.join(subdir, file);
-          const content = fs.readFileSync(filePath, 'utf8');
-          const basename = file.replace(/\.md$/, '');
-          const relPath = `${entry}/${basename}`;
-          const stat = fs.statSync(filePath);
-          memories.push({ id: `file:${relPath}`, source: 'file', file: relPath, title: basename, data: content.trim(), createdAt: stat.mtime.toISOString() });
+    const scanDir = (dir, prefix = '') => {
+      let entries;
+      try { entries = fs.readdirSync(dir); } catch { return; }
+      for (const entry of entries) {
+        const fullPath = path.join(dir, entry);
+        const stat = (() => { try { return fs.statSync(fullPath); } catch { return null; } })();
+        if (!stat) continue;
+        if (stat.isDirectory() && !prefix) {
+          scanDir(fullPath, entry + '/');
+        } else if (entry.endsWith('.md') && stat.isFile()) {
+          const content = fs.readFileSync(fullPath, 'utf8');
+          const basename = entry.replace(/\.md$/, '');
+          const relName = prefix + basename;
+          const dateMatch = basename.match(/^(\d{4}-\d{2}-\d{2})/);
+          if (prefix) {
+            memories.push({ id: `file:${relName}`, source: 'file', file: relName, title: basename, data: content.trim(), createdAt: stat.mtime.toISOString() });
+          } else {
+            const sections = content.split(/^(?=## )/m);
+            for (const section of sections) {
+              const trimmed = section.trim();
+              if (!trimmed) continue;
+              const headingMatch = trimmed.match(/^##\s+(.+)/);
+              const heading = headingMatch ? headingMatch[1].trim() : null;
+              const body = headingMatch ? trimmed.slice(trimmed.indexOf('\n') + 1).trim() : trimmed;
+              if (!heading && body.match(/^#\s+/) && body.split('\n').length <= 2) continue;
+              const title = heading || basename;
+              memories.push({ id: `file:${basename}:${title}`, source: 'file', file: basename, title, data: heading ? `**${title}**\n${body}` : body, createdAt: dateMatch ? `${dateMatch[1]}T00:00:00Z` : stat.mtime.toISOString() });
+            }
+          }
         }
       }
-    } catch { /* ignore */ }
+    };
+    scanDir(this.filesDir);
     return memories;
   }
 
-  async function _handleMemoryUpdate(req, res, params) {
-    const id = params.id;
+  async update(req, res, params) {
     try {
       const chunks = [];
       for await (const chunk of req) chunks.push(chunk);
-      const body = JSON.parse(Buffer.concat(chunks).toString());
-      const newData = (body.data || '').trim();
-      if (!newData) return send(res, 400, { error: 'Missing data field' });
-      const result = await _memoryProvider.update(id, newData);
-      send(res, 200, { ok: true, result });
+      const { data } = JSON.parse(Buffer.concat(chunks).toString());
+      if (!(data || '').trim()) return send(res, 400, { error: 'Missing data field' });
+      send(res, 200, { ok: true, result: await this.provider.update(params.id, data.trim()) });
     } catch (err) { send(res, 502, { error: 'Failed to update memory', detail: err.message }); }
   }
 
-  async function _handleMemoryDelete(req, res, params) {
-    const id = params.id;
+  async delete(req, res, params) {
+    try { send(res, 200, { ok: true, result: await this.provider.delete(params.id) }); }
+    catch (err) { send(res, 502, { error: `Failed to reach ${this.provider.name}`, detail: err.message }); }
+  }
+
+  async status(req, res) {
+    const status = await this.provider.status();
+    send(res, 200, { provider: this.provider.name, host: this.config.host, port: this.config.port, collection: this.config.collection, backend: status, memoryFilesDir: this.filesDir, memoryFilesDirExists: fs.existsSync(this.filesDir) });
+  }
+}
+
+// ─── Shared helpers (used by _GatewayClient inside createApp) ────────────────
+
+function syncThreadUnreadCount(db, threadId) {
+  const count = db.prepare('SELECT COUNT(*) as c FROM unread_messages WHERE thread_id = ?').get(threadId).c;
+  db.prepare('UPDATE threads SET unread_count = ? WHERE id = ?').run(count, threadId);
+  return count;
+}
+
+function parseSessionKey(sessionKey) {
+  if (!sessionKey) return null;
+  const match = sessionKey.match(/^agent:([^:]+):([^:]+):chat:([^:]+)$/);
+  if (!match) return null;
+  return { agent: match[1], workspace: match[2], threadId: match[3] };
+}
+
+function extractContent(message) {
+  if (!message) return '';
+  if (typeof message.content === 'string') return message.content;
+  if (Array.isArray(message.content)) {
+    return message.content.filter(p => p.type === 'text').map(p => p.text).join('');
+  }
+  return '';
+}
+
+function isSilentReplyExact(text, token = 'NO_REPLY') {
+  if (!text) return false;
+  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(`^\\s*${escaped}\\s*$`).test(text);
+}
+
+function isSilentReplyPrefix(text, token = 'NO_REPLY') {
+  if (!text) return false;
+  const trimmed = text.trimStart();
+  if (!trimmed) return false;
+  if (trimmed !== trimmed.toUpperCase()) return false;
+  const normalized = trimmed.toUpperCase();
+  if (normalized.length < 2) return false;
+  if (/[^A-Z_]/.test(normalized)) return false;
+  const tokenUpper = token.toUpperCase();
+  if (!tokenUpper.startsWith(normalized)) return false;
+  if (normalized.includes('_')) return true;
+  return tokenUpper === 'NO_REPLY' && normalized === 'NO';
+}
+
+function stripTrailingSentinel(text, token = 'NO_REPLY') {
+  if (!text) return text;
+  const escaped = token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return text.replace(new RegExp(`(?:^|\\s+|\\*+)${escaped}\\s*$`), '').trim();
+}
+
+function stripFinalTags(text) {
+  if (!text) return text;
+  return text.replace(/<\s*\/?\s*final\s*>/gi, '');
+}
+
+function sanitizeAssistantContent(text) {
+  if (!text) return text;
+  let out = stripFinalTags(text);
+  out = out.replace(/^(?:[ \t]*\r?\n)+/, '');
+  if (out.includes('NO_REPLY'))     out = stripTrailingSentinel(out, 'NO_REPLY');
+  if (out.includes('HEARTBEAT_OK')) out = stripTrailingSentinel(out, 'HEARTBEAT_OK');
+  return out;
+}
+
+function generateActivitySummary(steps) {
+  const toolSteps = steps.filter(s => s.type === 'tool' && s.phase !== 'result' && s.phase !== 'update');
+  const hasThinking = steps.some(s => s.type === 'thinking' && s.text);
+  const hasNarration = steps.some(s => s.type === 'assistant' && s.text?.trim());
+  if (toolSteps.length === 0 && !hasThinking && !hasNarration) return null;
+  if (toolSteps.length === 0 && hasThinking) return 'Reasoned through the problem';
+  if (toolSteps.length === 0 && hasNarration) return 'Processed in multiple steps';
+  const counts = {};
+  for (const s of toolSteps) { const name = s.name || 'unknown'; counts[name] = (counts[name] || 0) + 1; }
+  const toolNames = { web_search:'searched the web', web_fetch:'fetched web pages', Read:'read files', read:'read files', Write:'wrote files', write:'wrote files', Edit:'edited files', edit:'edited files', exec:'ran commands', Bash:'ran commands', browser:'browsed the web', memory_search:'searched memory', memory_store:'saved to memory', image:'analyzed images', message:'sent messages', sessions_spawn:'spawned sub-agents', cron:'managed cron jobs', Grep:'searched code', grep:'searched code', Glob:'found files', glob:'found files' };
+  const parts = [];
+  for (const [name, count] of Object.entries(counts)) {
+    const friendly = toolNames[name];
+    parts.push(friendly ? (count > 1 ? `${friendly} (${count}×)` : friendly) : (count > 1 ? `used ${name} (${count}×)` : `used ${name}`));
+  }
+  if (parts.length === 0) return null;
+  if (parts.length === 1) return parts[0].charAt(0).toUpperCase() + parts[0].slice(1);
+  const last = parts.pop();
+  return (parts.join(', ') + ' and ' + last).replace(/^./, c => c.toUpperCase());
+}
+
+function writeActivityToDb(getDbFn, broadcastFn, runId, log) {
+  if (!log._parsed) log._parsed = parseSessionKey(log.sessionKey);
+  const parsed = log._parsed;
+  if (!parsed) return;
+  const db = getDbFn(parsed.workspace);
+  if (!db) return;
+  const cleanSteps = log.steps.map(s => { const c = {...s}; delete c._sealed; return c; });
+  const summary = generateActivitySummary(log.steps);
+  const now = Date.now();
+  if (!log._messageId) {
+    const thread = db.prepare('SELECT id FROM threads WHERE id = ?').get(parsed.threadId);
+    if (!thread) return;
+    const messageId = `gw-activity-${runId}`;
+    const metadata = { activityLog: cleanSteps, activitySummary: summary, pending: true };
+    try {
+      db.prepare(`INSERT OR IGNORE INTO messages (id, thread_id, role, content, status, metadata, timestamp, created_at) VALUES (?, ?, 'assistant', '', 'sent', ?, ?, ?)`).run(messageId, parsed.threadId, JSON.stringify(metadata), now, now);
+      log._messageId = messageId;
+      broadcastFn(JSON.stringify({ type: 'clawchats', event: 'message-saved', threadId: parsed.threadId, workspace: parsed.workspace, messageId, timestamp: now }));
+    } catch (err) { console.error(`[activity] Failed to write activity ${messageId}:`, err.message); }
+  } else {
+    const existing = db.prepare('SELECT metadata FROM messages WHERE id = ?').get(log._messageId);
+    const metadata = existing?.metadata ? JSON.parse(existing.metadata) : {};
+    metadata.activityLog = cleanSteps;
+    metadata.activitySummary = summary;
+    metadata.pending = true;
+    db.prepare('UPDATE messages SET metadata = ? WHERE id = ?').run(JSON.stringify(metadata), log._messageId);
+  }
+}
+
+// ─── createApp Factory ───────────────────────────────────────────────────────
+// Returns an isolated instance of the app state + handlers.
+// Used by the plugin (signaling/index.js) to embed ClawChats logic without
+// spinning up a standalone HTTP server.
+
+export function createApp(config = {}) {
+  // ── Config-dependent constants ─────────────────────────────────────────────
+  const _DATA_DIR = config.dataDir || path.join(__dirname, 'data');
+  const _UPLOADS_DIR = config.uploadsDir || path.join(__dirname, 'uploads');
+  const _WORKSPACES_FILE = path.join(_DATA_DIR, 'workspaces.json');
+  const _SETTINGS_FILE = path.join(_DATA_DIR, 'settings.json');
+  const _INTELLIGENCE_DIR = path.join(_DATA_DIR, 'intelligence');
+
+  let _AUTH_TOKEN = config.authToken !== undefined
+    ? config.authToken
+    : (process.env.CLAWCHATS_AUTH_TOKEN || process.env.SHELLCHAT_AUTH_TOKEN || parseConfigField('authToken') || '');
+
+  // Separate token for gateway WS auth (falls back to _AUTH_TOKEN for direct mode)
+  const _GATEWAY_TOKEN = config.gatewayToken !== undefined
+    ? config.gatewayToken
+    : _AUTH_TOKEN;
+
+  const _GATEWAY_WS_URL = config.gatewayUrl || discoverGatewayWsUrl();
+
+  // ── Mutable singleton state ────────────────────────────────────────────────
+  const _dbCache = new Map();
+  let _workspacesConfig = null;
+  const _debugLogger = new DebugLogger(_DATA_DIR);
+
+  const _MEMORY_CONFIG = discoverMemoryConfig();
+  const _memoryProvider = createMemoryProvider(_MEMORY_CONFIG);
+  _memoryProvider.init().catch(err => console.error('[createApp] Memory provider init error:', err.message));
+
+  const _MEMORY_FILES_DIR = path.join(_MEMORY_CONFIG.workspaceDir, 'memory');
+
+  // ── Workspace helpers ──────────────────────────────────────────────────────
+  function _loadWorkspaces() {
     try {
-      const result = await _memoryProvider.delete(id);
-      send(res, 200, { ok: true, result });
-    } catch (err) { send(res, 502, { error: `Failed to reach ${_memoryProvider.name}`, detail: err.message }); }
+      return JSON.parse(fs.readFileSync(_WORKSPACES_FILE, 'utf8'));
+    } catch {
+      const initial = {
+        active: 'default',
+        workspaces: {
+          default: { name: 'default', label: 'Default', createdAt: Date.now() }
+        }
+      };
+      fs.writeFileSync(_WORKSPACES_FILE, JSON.stringify(initial, null, 2));
+      return initial;
+    }
+  }
+
+  function _saveWorkspaces(data) {
+    fs.writeFileSync(_WORKSPACES_FILE, JSON.stringify(data, null, 2));
+  }
+
+  function _getWorkspaces() {
+    if (!_workspacesConfig) _workspacesConfig = _loadWorkspaces();
+    return _workspacesConfig;
+  }
+
+  function _setWorkspaces(data) {
+    _workspacesConfig = data;
+    _saveWorkspaces(data);
+  }
+
+  // ── Database helpers ───────────────────────────────────────────────────────
+  function _getDb(workspaceName) {
+    if (_dbCache.has(workspaceName)) return _dbCache.get(workspaceName);
+    const dbPath = path.join(_DATA_DIR, `${workspaceName}.db`);
+    const db = new Database(dbPath);
+    db.pragma('journal_mode = WAL');
+    db.pragma('foreign_keys = ON');
+    migrate(db);
+    _dbCache.set(workspaceName, db);
+    return db;
+  }
+
+  function _getActiveDb() {
+    return _requestDbStore.getStore() || _getDb(_getWorkspaces().active);
+  }
+
+  function _closeDb(workspaceName) {
+    const db = _dbCache.get(workspaceName);
+    if (db) { db.close(); _dbCache.delete(workspaceName); }
+  }
+
+  function _closeAllDbs() {
+    for (const [, db] of _dbCache) db.close();
+    _dbCache.clear();
+  }
+
+  function _ensureDirs() {
+    fs.mkdirSync(_DATA_DIR, { recursive: true });
+    fs.mkdirSync(_UPLOADS_DIR, { recursive: true });
   }
 
-  async function _handleMemoryStatus(req, res) {
-    const status = await _memoryProvider.status();
-    const filesExist = fs.existsSync(_MEMORY_FILES_DIR);
-    send(res, 200, { provider: _memoryProvider.name, host: _MEMORY_CONFIG.host, port: _MEMORY_CONFIG.port, collection: _MEMORY_CONFIG.collection, backend: status, memoryFilesDir: _MEMORY_FILES_DIR, memoryFilesDirExists: filesExist });
+  // ── Auth (closes over _AUTH_TOKEN) ─────────────────────────────────────────
+  function _checkAuth(req, res) {
+    if (!_AUTH_TOKEN) return true;
+    const auth = req.headers.authorization;
+    if (!auth || !auth.startsWith('Bearer ')) {
+      sendError(res, 401, 'Missing or invalid Authorization header');
+      return false;
+    }
+    const token = auth.slice(7);
+    if (token !== _AUTH_TOKEN) {
+      sendError(res, 401, 'Invalid auth token');
+      return false;
+    }
+    return true;
   }
 
   // ── GatewayClient (scoped to this factory instance) ───────────────────────
@@ -4628,6 +2549,28 @@ export function createApp(config = {}) {
 
   const _gatewayClient = new _GatewayClient();
 
+  const _broadcast = (msg) => _gatewayClient.broadcastToBrowsers(msg);
+
+  function _handleGetSettings(req, res) {
+    try {
+      const data = fs.existsSync(_SETTINGS_FILE) ? JSON.parse(fs.readFileSync(_SETTINGS_FILE, 'utf8')) : {};
+      return send(res, 200, data);
+    } catch { return send(res, 200, {}); }
+  }
+
+  async function _handleSaveSettings(req, res) {
+    const body = await parseBody(req);
+    fs.mkdirSync(path.dirname(_SETTINGS_FILE), { recursive: true });
+    fs.writeFileSync(_SETTINGS_FILE, JSON.stringify(body, null, 2));
+    return send(res, 200, { ok: true });
+  }
+
+  const workspaces = new WorkspaceController({ getDb: _getDb, closeDb: _closeDb, getWorkspaces: _getWorkspaces, setWorkspaces: _setWorkspaces, dataDir: _DATA_DIR, broadcast: _broadcast });
+  const threads    = new ThreadController({ getActiveDb: _getActiveDb, getWorkspaces: _getWorkspaces, uploadsDir: _UPLOADS_DIR, broadcast: _broadcast });
+  const messages   = new MessageController({ getActiveDb: _getActiveDb, getWorkspaces: _getWorkspaces, broadcast: _broadcast });
+  const files      = new FileController({ getActiveDb: _getActiveDb, getWorkspaces: _getWorkspaces, uploadsDir: _UPLOADS_DIR, intelligenceDir: _INTELLIGENCE_DIR });
+  const memory     = new MemoryController({ memoryProvider: _memoryProvider, memoryFilesDir: _MEMORY_FILES_DIR, memoryConfig: _MEMORY_CONFIG });
+
   // ── handleRequest (scoped to factory state) ────────────────────────────────
   async function _handleRequest(req, res) {
     const _wsName = req.headers?.['x-workspace'];
@@ -4668,7 +2611,7 @@ export function createApp(config = {}) {
     }
 
     let p;
-    if ((p = matchRoute(method, urlPath, 'GET /api/uploads/:threadId/:fileId'))) return _handleServeUpload(req, res, p);
+    if ((p = matchRoute(method, urlPath, 'GET /api/uploads/:threadId/:fileId'))) return files.serveUpload(req, res, p);
 
     // Custom emoji listing (no auth)
     if (method === 'GET' && urlPath === '/api/emoji') {
@@ -4743,12 +2686,12 @@ export function createApp(config = {}) {
       if (method === 'PUT' && urlPath === '/api/workspace/file') return await handleWorkspaceFileWrite(req, res, query);
       if (method === 'DELETE' && urlPath === '/api/workspace/file') return handleWorkspaceFileDelete(req, res, query);
       if (method === 'POST' && urlPath === '/api/workspace/upload') return await handleWorkspaceUpload(req, res, query);
-      if (method === 'GET' && urlPath === '/api/memory/status') return await _handleMemoryStatus(req, res);
-      if (method === 'GET' && urlPath === '/api/memory/list') return await _handleMemoryList(req, res, query);
-      if (method === 'GET' && urlPath === '/api/memory/search') return await _handleMemorySearch(req, res, query);
-      if (method === 'GET' && urlPath === '/api/memory/files') return _handleMemoryFiles(req, res, query);
-      if ((p = matchRoute(method, urlPath, 'PUT /api/memory/:id'))) return await _handleMemoryUpdate(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'DELETE /api/memory/:id'))) return await _handleMemoryDelete(req, res, p);
+      if (method === 'GET' && urlPath === '/api/memory/status') return await memory.status(req, res);
+      if (method === 'GET' && urlPath === '/api/memory/list') return await memory.list(req, res, query);
+      if (method === 'GET' && urlPath === '/api/memory/search') return await memory.search(req, res, query);
+      if (method === 'GET' && urlPath === '/api/memory/files') return memory.files(req, res, query);
+      if ((p = matchRoute(method, urlPath, 'PUT /api/memory/:id'))) return await memory.update(req, res, p);
+      if ((p = matchRoute(method, urlPath, 'DELETE /api/memory/:id'))) return await memory.delete(req, res, p);
       if (method === 'GET' && urlPath === '/api/settings') return _handleGetSettings(req, res);
       if (method === 'PUT' && urlPath === '/api/settings') return await _handleSaveSettings(req, res);
       if (method === 'POST' && urlPath === '/api/transcribe') return await handleTranscribe(req, res);
@@ -4760,20 +2703,20 @@ export function createApp(config = {}) {
           return send(res, 200, { agents });
         } catch { return send(res, 200, { agents: ['main'] }); }
       }
-      if (method === 'GET' && urlPath === '/api/workspaces') return _handleGetWorkspaces(req, res);
-      if (method === 'POST' && urlPath === '/api/workspaces') return await _handleCreateWorkspace(req, res);
-      if ((p = matchRoute(method, urlPath, 'PATCH /api/workspaces/:name'))) return await _handleUpdateWorkspace(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'DELETE /api/workspaces/:name'))) return _handleDeleteWorkspace(req, res, p);
-      if (method === 'POST' && urlPath === '/api/workspaces/reorder') return await _handleReorderWorkspaces(req, res);
-      if ((p = matchRoute(method, urlPath, 'POST /api/workspaces/:name/activate'))) return _handleActivateWorkspace(req, res, p);
-      if (method === 'GET' && urlPath === '/api/threads') return _handleGetThreads(req, res, {}, query);
-      if (method === 'GET' && urlPath === '/api/threads/unread') return _handleGetUnreadThreads(req, res);
-      if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/mark-read'))) return await _handleMarkMessagesRead(req, res, p);
-      if (method === 'POST' && urlPath === '/api/threads') return await _handleCreateThread(req, res);
-      if ((p = matchRoute(method, urlPath, 'GET /api/threads/:id/messages'))) return _handleGetMessages(req, res, p, query);
-      if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/messages'))) return await _handleCreateMessage(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'DELETE /api/threads/:id/messages/:messageId'))) return _handleDeleteMessage(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/context-fill'))) return _handleContextFill(req, res, p);
+      if (method === 'GET' && urlPath === '/api/workspaces') return workspaces.getAll(req, res);
+      if (method === 'POST' && urlPath === '/api/workspaces') return await workspaces.create(req, res);
+      if ((p = matchRoute(method, urlPath, 'PATCH /api/workspaces/:name'))) return await workspaces.update(req, res, p);
+      if ((p = matchRoute(method, urlPath, 'DELETE /api/workspaces/:name'))) return workspaces.delete(req, res, p);
+      if (method === 'POST' && urlPath === '/api/workspaces/reorder') return await workspaces.reorder(req, res);
+      if ((p = matchRoute(method, urlPath, 'POST /api/workspaces/:name/activate'))) return workspaces.activate(req, res, p);
+      if (method === 'GET' && urlPath === '/api/threads') return threads.getAll(req, res, {}, query);
+      if (method === 'GET' && urlPath === '/api/threads/unread') return threads.getUnread(req, res);
+      if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/mark-read'))) return await threads.markRead(req, res, p);
+      if (method === 'POST' && urlPath === '/api/threads') return await threads.create(req, res);
+      if ((p = matchRoute(method, urlPath, 'GET /api/threads/:id/messages'))) return messages.getAll(req, res, p, query);
+      if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/messages'))) return await messages.create(req, res, p);
+      if ((p = matchRoute(method, urlPath, 'DELETE /api/threads/:id/messages/:messageId'))) return messages.delete(req, res, p);
+      if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/context-fill'))) return messages.contextFill(req, res, p);
       if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/generate-title'))) {
         const db = _getActiveDb();
         const thread = db.prepare('SELECT * FROM threads WHERE id = ?').get(p.id);
@@ -4783,15 +2726,15 @@ export function createApp(config = {}) {
         _gatewayClient.generateThreadTitle(db, p.id, activeWs);
         return send(res, 200, { ok: true });
       }
-      if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/upload'))) return await _handleUpload(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'GET /api/threads/:id/intelligence'))) return _handleGetIntelligence(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/intelligence'))) return await _handleSaveIntelligence(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'GET /api/threads/:id'))) return _handleGetThread(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'PATCH /api/threads/:id'))) return await _handleUpdateThread(req, res, p);
-      if ((p = matchRoute(method, urlPath, 'DELETE /api/threads/:id'))) return _handleDeleteThread(req, res, p);
-      if (method === 'GET' && urlPath === '/api/search') return _handleSearch(req, res, {}, query);
-      if (method === 'GET' && urlPath === '/api/export') return _handleExport(req, res);
-      if (method === 'POST' && urlPath === '/api/import') return await _handleImport(req, res);
+      if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/upload'))) return await files.upload(req, res, p);
+      if ((p = matchRoute(method, urlPath, 'GET /api/threads/:id/intelligence'))) return files.getIntelligence(req, res, p);
+      if ((p = matchRoute(method, urlPath, 'POST /api/threads/:id/intelligence'))) return await files.saveIntelligence(req, res, p);
+      if ((p = matchRoute(method, urlPath, 'GET /api/threads/:id'))) return threads.get(req, res, p);
+      if ((p = matchRoute(method, urlPath, 'PATCH /api/threads/:id'))) return await threads.update(req, res, p);
+      if ((p = matchRoute(method, urlPath, 'DELETE /api/threads/:id'))) return threads.delete(req, res, p);
+      if (method === 'GET' && urlPath === '/api/search') return messages.search(req, res, {}, query);
+      if (method === 'GET' && urlPath === '/api/export') return messages.export(req, res);
+      if (method === 'POST' && urlPath === '/api/import') return await messages.import(req, res);
       if (method === 'POST' && urlPath === '/api/active-thread') {
         const body = await parseBody(req);
         const { threadId, workspace } = body;