create-walle 0.1.0

package/template/wall-e/api-walle.js

@@ -0,0 +1,1073 @@
+'use strict';
+const Database = require('better-sqlite3');
+const path = require('path');
+
+const DATA_DIR = process.env.WALL_E_DATA_DIR || path.join(process.env.HOME, '.walle', 'data');
+const BRAIN_DB_PATH = path.join(DATA_DIR, 'wall-e-brain.db');
+
+let readDb = null;
+
+function getReadDb() {
+  if (!readDb) {
+    try {
+      readDb = new Database(BRAIN_DB_PATH, { readonly: true, fileMustExist: true });
+      readDb.pragma('journal_mode = WAL');
+    } catch (err) {
+      return null;
+    }
+  }
+  return readDb;
+}
+
+let brain = null;
+try { brain = require('./brain'); } catch {}
+
+function ensureBrainInit() {
+  if (!brain) return false;
+  try { brain.getDb(); } catch {
+    try { brain.initDb(); } catch { return false; }
+  }
+  return true;
+}
+
+// --- Helpers ---
+
+function jsonResponse(res, data, status = 200) {
+  const body = JSON.stringify(data);
+  res.writeHead(status, { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) });
+  res.end(body);
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on('data', chunk => {
+      size += chunk.length;
+      if (size > 1024 * 1024) { req.destroy(); reject(new Error('Body too large')); return; }
+      chunks.push(chunk);
+    });
+    req.on('end', () => {
+      try { resolve(JSON.parse(Buffer.concat(chunks).toString())); }
+      catch { resolve({}); }
+    });
+    req.on('error', reject);
+  });
+}
+
+function parseLimit(params, defaultVal = 50) {
+  return Math.min(Math.max(parseInt(params.get('limit')) || defaultVal, 1), 500);
+}
+
+function parseOffset(params) {
+  return Math.max(parseInt(params.get('offset')) || 0, 0);
+}
+
+// --- Individual route handlers (exported for testability) ---
+
+function getStatus() {
+  const db = getReadDb();
+  if (!db) return { error: 'Brain database not available' };
+
+  const ownerRow = db.prepare('SELECT value FROM owner WHERE key = ?').get('name');
+  const owner = ownerRow ? ownerRow.value : null;
+
+  const memory_count = db.prepare('SELECT count(*) as cnt FROM memories').get().cnt;
+  const knowledge_count = db.prepare('SELECT count(*) as cnt FROM knowledge').get().cnt;
+  const people_count = db.prepare('SELECT count(*) as cnt FROM people').get().cnt;
+  const pattern_count = db.prepare('SELECT count(*) as cnt FROM patterns').get().cnt;
+  const pending_question_count = db.prepare("SELECT count(*) as cnt FROM pending_questions WHERE status = 'pending'").get().cnt;
+
+  return {
+    owner,
+    stats: { memory_count, knowledge_count, people_count, pattern_count, pending_question_count }
+  };
+}
+
+function getKnowledgeList(params) {
+  const db = getReadDb();
+  if (!db) return [];
+
+  const limit = parseLimit(params);
+  const offset = parseOffset(params);
+  const subject = params.get('subject');
+  const category = params.get('category');
+  const status = params.get('status');
+
+  const conditions = [];
+  const values = [];
+
+  if (subject) { conditions.push('subject = ?'); values.push(subject); }
+  if (category) { conditions.push('category = ?'); values.push(category); }
+  if (status) { conditions.push('status = ?'); values.push(status); }
+
+  let sql = 'SELECT * FROM knowledge';
+  if (conditions.length > 0) sql += ' WHERE ' + conditions.join(' AND ');
+  sql += ' ORDER BY last_confirmed DESC LIMIT ? OFFSET ?';
+  values.push(limit, offset);
+
+  return db.prepare(sql).all(...values);
+}
+
+function getMemoriesList(params) {
+  const db = getReadDb();
+  if (!db) return [];
+
+  const limit = parseLimit(params);
+  const offset = parseOffset(params);
+  const source = params.get('source');
+  const since = params.get('since');
+
+  const conditions = [];
+  const values = [];
+
+  if (source) { conditions.push('source = ?'); values.push(source); }
+  if (since) { conditions.push('timestamp >= ?'); values.push(since); }
+
+  let sql = 'SELECT * FROM memories';
+  if (conditions.length > 0) sql += ' WHERE ' + conditions.join(' AND ');
+  sql += ' ORDER BY timestamp DESC LIMIT ? OFFSET ?';
+  values.push(limit, offset);
+
+  return db.prepare(sql).all(...values);
+}
+
+function getPeopleList() {
+  const db = getReadDb();
+  if (!db) return [];
+  return db.prepare('SELECT * FROM people ORDER BY name').all();
+}
+
+function getTimeline(params) {
+  const db = getReadDb();
+  if (!db) return [];
+
+  const limit = parseLimit(params, 100);
+  const offset = parseOffset(params);
+
+  return db.prepare('SELECT * FROM memories ORDER BY timestamp DESC LIMIT ? OFFSET ?').all(limit, offset);
+}
+
+function getQuestionsList(params) {
+  const db = getReadDb();
+  if (!db) return [];
+
+  const status = params.get('status') || 'pending';
+  return db.prepare('SELECT * FROM pending_questions WHERE status = ? ORDER BY created_at DESC').all(status);
+}
+
+function getStats() {
+  const db = getReadDb();
+  if (!db) return { error: 'Brain database not available' };
+
+  const memory_count = db.prepare('SELECT count(*) as cnt FROM memories').get().cnt;
+  const knowledge_count = db.prepare('SELECT count(*) as cnt FROM knowledge').get().cnt;
+  const people_count = db.prepare('SELECT count(*) as cnt FROM people').get().cnt;
+  const pattern_count = db.prepare('SELECT count(*) as cnt FROM patterns').get().cnt;
+  const pending_question_count = db.prepare("SELECT count(*) as cnt FROM pending_questions WHERE status = 'pending'").get().cnt;
+
+  return { memory_count, knowledge_count, people_count, pattern_count, pending_question_count };
+}
+
+function getBrief(params) {
+  const db = getReadDb();
+  if (!db) return null;
+
+  const date = params.get('date') || new Date().toISOString().slice(0, 10);
+  return db.prepare('SELECT * FROM daily_summaries WHERE date = ?').get(date) || null;
+}
+
+// --- Main Route Handler ---
+
+function handleWalleApi(req, res, url) {
+  const p = url.pathname;
+  const m = req.method;
+  const params = url.searchParams;
+
+  // Only handle /api/wall-e/* routes
+  if (!p.startsWith('/api/wall-e')) return false;
+
+  // GET /api/wall-e/health — simple liveness check
+  if (p === '/api/wall-e/health' && m === 'GET') {
+    return jsonResponse(res, { status: 'ok', uptime: process.uptime(), version: '0.1.0' }), true;
+  }
+
+  // GET /api/wall-e/slack/status — check Slack OAuth status
+  if (p === '/api/wall-e/slack/status' && m === 'GET') {
+    try {
+      const slackMcp = require('./tools/slack-mcp');
+      const token = slackMcp.loadToken();
+      jsonResponse(res, { data: { authenticated: !!token?.access_token, team: token?.team_name, user: token?.user_id, obtained_at: token?.obtained_at } });
+    } catch (e) {
+      jsonResponse(res, { data: { authenticated: false } });
+    }
+    return true;
+  }
+
+  // POST /api/wall-e/slack/auth — start OAuth flow (opens browser)
+  if (p === '/api/wall-e/slack/auth' && m === 'POST') {
+    try {
+      const slackMcp = require('./tools/slack-mcp');
+      slackMcp.authenticate().then(token => {
+        console.log('[wall-e] Slack OAuth completed');
+      }).catch(err => {
+        console.error('[wall-e] Slack OAuth failed:', err.message);
+      });
+      jsonResponse(res, { data: { message: 'OAuth flow started — check your browser' } });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // GET /api/wall-e/status
+  if (p === '/api/wall-e/status' && m === 'GET') {
+    const result = getStatus();
+    if (result.error) return jsonResponse(res, { error: result.error }, 503);
+
+    // Enrich with daemon/loop health info
+    const db = getReadDb();
+    let checkpoints = {};
+    if (db) {
+      try {
+        const rows = db.prepare('SELECT * FROM loop_checkpoints').all();
+        for (const row of rows) {
+          checkpoints[row.loop_name] = { last_run_at: row.last_run_at, updated_at: row.updated_at };
+        }
+      } catch {}
+    }
+
+    // Adapter statuses (best-effort from config)
+    let adapterStatuses = [];
+    try {
+      const fs = require('fs');
+      const cfgPath = require('path').join(__dirname, 'wall-e-config.json');
+      if (fs.existsSync(cfgPath)) {
+        const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
+        if (cfg.adapters) {
+          for (const [name, conf] of Object.entries(cfg.adapters)) {
+            adapterStatuses.push({ name, enabled: conf.enabled !== false });
+          }
+        }
+      }
+    } catch {}
+
+    return jsonResponse(res, {
+      data: {
+        ...result,
+        version: '0.1.0',
+        uptime: process.uptime(),
+        loop_health: checkpoints,
+        adapters: adapterStatuses,
+      }
+    }), true;
+  }
+
+  // GET /api/wall-e/knowledge
+  if (p === '/api/wall-e/knowledge' && m === 'GET') {
+    const data = getKnowledgeList(params);
+    return jsonResponse(res, { data }), true;
+  }
+
+  // GET /api/wall-e/memories
+  if (p === '/api/wall-e/memories' && m === 'GET') {
+    const data = getMemoriesList(params);
+    return jsonResponse(res, { data }), true;
+  }
+
+  // GET /api/wall-e/people
+  if (p === '/api/wall-e/people' && m === 'GET') {
+    const data = getPeopleList();
+    return jsonResponse(res, { data }), true;
+  }
+
+  // GET /api/wall-e/timeline
+  if (p === '/api/wall-e/timeline' && m === 'GET') {
+    const data = getTimeline(params);
+    return jsonResponse(res, { data }), true;
+  }
+
+  // GET /api/wall-e/questions
+  if (p === '/api/wall-e/questions' && m === 'GET') {
+    const data = getQuestionsList(params);
+    return jsonResponse(res, { data }), true;
+  }
+
+  // POST /api/wall-e/questions/:id/answer
+  const answerMatch = p.match(/^\/api\/wall-e\/questions\/([^/]+)\/answer$/);
+  if (answerMatch && m === 'POST') {
+    if (!brain) return jsonResponse(res, { error: 'Brain module not available for writes' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        brain.answerQuestion(answerMatch[1], {
+          answer: body.answer,
+          resolution_type: body.resolution_type
+        });
+        jsonResponse(res, { data: { ok: true } });
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 400);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // GET /api/wall-e/brief
+  if (p === '/api/wall-e/brief' && m === 'GET') {
+    const data = getBrief(params);
+    return jsonResponse(res, { data }), true;
+  }
+
+  // GET /api/wall-e/stats
+  if (p === '/api/wall-e/stats' && m === 'GET') {
+    const result = getStats();
+    if (result.error) return jsonResponse(res, { error: result.error }, 503), true;
+    return jsonResponse(res, { data: result }), true;
+  }
+
+  // PUT /api/wall-e/knowledge/:id
+  const knowledgeMatch = p.match(/^\/api\/wall-e\/knowledge\/([^/]+)$/);
+  if (knowledgeMatch && m === 'PUT') {
+    if (!brain) return jsonResponse(res, { error: 'Brain module not available for writes' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        brain.updateKnowledgeStatus(knowledgeMatch[1], body.status);
+        jsonResponse(res, { data: { ok: true } });
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 400);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // POST /api/wall-e/chat — supports SSE streaming via Accept header or ?stream=1
+  if (p === '/api/wall-e/chat' && m === 'POST') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    const wantsStream = params.get('stream') === '1' || (req.headers.accept || '').includes('text/event-stream');
+    readBody(req).then(async body => {
+      if (!body.message) {
+        jsonResponse(res, { error: 'message is required' }, 400);
+        return;
+      }
+      try {
+        const chatModule = require('./chat');
+        if (wantsStream) {
+          // SSE streaming mode — send progress events in real-time
+          res.writeHead(200, {
+            'Content-Type': 'text/event-stream',
+            'Cache-Control': 'no-cache',
+            'Connection': 'keep-alive',
+          });
+          const sendEvent = (event) => {
+            try { res.write('data: ' + JSON.stringify(event) + '\n\n'); } catch {}
+          };
+          const result = await chatModule.chat(body.message, {
+            channel: body.channel || 'ctm',
+            session_id: body.session_id || 'default',
+            onProgress: sendEvent,
+          });
+          sendEvent({ type: 'done', reply: result.reply });
+          res.end();
+        } else {
+          // Classic JSON mode (backwards compatible)
+          const result = await chatModule.chat(body.message, {
+            channel: body.channel || 'ctm',
+            session_id: body.session_id || 'default',
+          });
+          jsonResponse(res, { data: result });
+        }
+      } catch (err) {
+        if (wantsStream) {
+          try { res.write('data: ' + JSON.stringify({ type: 'error', error: err.message }) + '\n\n'); } catch {}
+          try { res.end(); } catch {}
+        } else {
+          jsonResponse(res, { error: err.message }, 500);
+        }
+      }
+    }).catch(e => {
+      if (wantsStream) {
+        try { res.write('data: ' + JSON.stringify({ type: 'error', error: e.message }) + '\n\n'); } catch {}
+        try { res.end(); } catch {}
+      } else {
+        jsonResponse(res, { error: e.message }, 400);
+      }
+    });
+    return true;
+  }
+
+  // GET /api/wall-e/chat/history
+  if (p === '/api/wall-e/chat/history' && m === 'GET') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    try {
+      const sessionId = params.get('session_id') || 'default';
+      const limit = parseLimit(params, 100);
+      const data = brain.listChatMessages({ session_id: sessionId, limit });
+      jsonResponse(res, { data });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // POST /api/wall-e/chat/delete
+  if (p === '/api/wall-e/chat/delete' && m === 'POST') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        brain.deleteChatMessages({
+          session_id: body.session_id || 'default',
+          user_content: body.user_content,
+          assistant_content: body.assistant_content,
+        });
+        jsonResponse(res, { data: { ok: true } });
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 500);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // POST /api/wall-e/tasks/:id/stop — proxy to WALL-E daemon to kill running process
+  const taskStopMatch = p.match(/^\/api\/wall-e\/tasks\/([^/]+)\/stop$/);
+  if (taskStopMatch && m === 'POST') {
+    const daemonPort = process.env.WALL_E_PORT || 3457;
+    fetch(`http://localhost:${daemonPort}/api/wall-e/tasks/${taskStopMatch[1]}/stop`, { method: 'POST' })
+      .then(resp => resp.json())
+      .then(data => jsonResponse(res, data))
+      .catch(() => jsonResponse(res, { data: { stopped: false, error: 'daemon_offline' } }));
+    return true;
+  }
+
+  // GET /api/wall-e/tasks/:id/logs — proxy to WALL-E daemon (port 3457) for live logs
+  const taskLogsMatch = p.match(/^\/api\/wall-e\/tasks\/([^/]+)\/logs$/);
+  if (taskLogsMatch && m === 'GET') {
+    const daemonPort = process.env.WALL_E_PORT || 3457;
+    fetch(`http://localhost:${daemonPort}/api/wall-e/tasks/${taskLogsMatch[1]}/logs`)
+      .then(resp => resp.json())
+      .then(data => jsonResponse(res, data))
+      .catch(() => jsonResponse(res, { data: { lines: [], status: 'daemon_offline' } }));
+    return true;
+  }
+
+  // GET /api/wall-e/tasks
+  if (p === '/api/wall-e/tasks' && m === 'GET') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    try {
+      const status = params.get('status') || undefined;
+      const limit = parseLimit(params, 50);
+      const data = brain.listTasks({ status, limit }).map(function(t) {
+        if (t.started_at && t.completed_at) {
+          // Normalize timestamps: append 'Z' if missing to ensure UTC parsing
+          const s = t.started_at.includes('Z') || t.started_at.includes('+') ? t.started_at : t.started_at.replace(' ', 'T') + 'Z';
+          const c = t.completed_at.includes('Z') || t.completed_at.includes('+') ? t.completed_at : t.completed_at.replace(' ', 'T') + 'Z';
+          const dur = new Date(c).getTime() - new Date(s).getTime();
+          if (dur > 0 && dur < 86400000) t.last_duration_ms = dur; // sanity: max 24h
+        }
+        return t;
+      });
+      jsonResponse(res, { data });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // POST /api/wall-e/tasks
+  if (p === '/api/wall-e/tasks' && m === 'POST') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        if (!body.title) { jsonResponse(res, { error: 'title is required' }, 400); return; }
+        const result = brain.insertTask({
+          title: body.title,
+          description: body.description,
+          priority: body.priority,
+          type: body.type,
+          schedule: body.schedule,
+          due_at: body.due_at,
+          skill: body.skill,
+          skill_config: body.skill_config ? (typeof body.skill_config === 'string' ? body.skill_config : JSON.stringify(body.skill_config)) : undefined,
+        });
+        jsonResponse(res, { data: { id: result.id } }, 201);
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 400);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // PUT /api/wall-e/tasks/:id
+  const taskUpdateMatch = p.match(/^\/api\/wall-e\/tasks\/([^/]+)$/);
+  if (taskUpdateMatch && m === 'PUT') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        // When schedule changes, recompute next_run_at
+        if (body.schedule && !body.next_run_at) {
+          try {
+            const { computeNextDue } = require('./loops/tasks');
+            body.next_run_at = computeNextDue(body.schedule);
+          } catch {}
+        }
+        brain.updateTask(taskUpdateMatch[1], body);
+        jsonResponse(res, { data: { ok: true } });
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 400);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // DELETE /api/wall-e/tasks/:id (reuse taskUpdateMatch regex)
+  if (taskUpdateMatch && m === 'DELETE') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    try {
+      brain.deleteTask(taskUpdateMatch[1]);
+      jsonResponse(res, { data: { ok: true } });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // GET /api/wall-e/chat/search
+  if (p === '/api/wall-e/chat/search' && m === 'GET') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    try {
+      const query = params.get('q') || '';
+      const limit = parseLimit(params, 50);
+      const data = brain.searchChatMessages({ query, limit });
+      jsonResponse(res, { data });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // GET /api/wall-e/confidence
+  if (p === '/api/wall-e/confidence' && m === 'GET') {
+    if (!brain) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    try {
+      const confidence = require('./decision/confidence');
+      const data = confidence.listDomainConfidences();
+      jsonResponse(res, { data });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // GET /api/wall-e/actions
+  if (p === '/api/wall-e/actions' && m === 'GET') {
+    if (!brain) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    try {
+      const status = params.get('status') || undefined;
+      const domain = params.get('domain') || undefined;
+      const limit = parseLimit(params, 50);
+      const data = brain.listActions({ status, domain, limit });
+      jsonResponse(res, { data });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // POST /api/wall-e/actions/:id/approve
+  const approveMatch = p.match(/^\/api\/wall-e\/actions\/([^/]+)\/approve$/);
+  if (approveMatch && m === 'POST') {
+    if (!brain) return jsonResponse(res, { error: 'Brain module not available for writes' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        const actionId = approveMatch[1];
+        const action = brain.getAction(actionId);
+        if (!action) { jsonResponse(res, { error: 'Action not found' }, 404); return; }
+        brain.updateActionStatus(actionId, 'approved');
+        // Record in confidence system
+        const confidence = require('./decision/confidence');
+        if (action.domain) {
+          const graduation = confidence.recordAction(action.domain, true);
+          jsonResponse(res, { data: { ok: true, graduation } });
+        } else {
+          jsonResponse(res, { data: { ok: true } });
+        }
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 400);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // POST /api/wall-e/actions/:id/reject
+  const rejectMatch = p.match(/^\/api\/wall-e\/actions\/([^/]+)\/reject$/);
+  if (rejectMatch && m === 'POST') {
+    if (!brain) return jsonResponse(res, { error: 'Brain module not available for writes' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        const actionId = rejectMatch[1];
+        const action = brain.getAction(actionId);
+        if (!action) { jsonResponse(res, { error: 'Action not found' }, 404); return; }
+        brain.updateActionStatus(actionId, 'rejected', body.review_note);
+        // Record in confidence system
+        const confidence = require('./decision/confidence');
+        if (action.domain) {
+          const graduation = confidence.recordAction(action.domain, false);
+          jsonResponse(res, { data: { ok: true, graduation } });
+        } else {
+          jsonResponse(res, { data: { ok: true } });
+        }
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 400);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // --- Agent-to-Agent Protocol ---
+
+  // POST /api/wall-e/agent/exchange
+  if (p === '/api/wall-e/agent/exchange' && m === 'POST') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    readBody(req).then(async body => {
+      try {
+        const agentApi = require('./channels/agent-api');
+        const result = await agentApi.handleInboundExchange(body);
+        if (result.error) {
+          jsonResponse(res, { error: result.error }, 400);
+        } else {
+          jsonResponse(res, { data: result });
+        }
+      } catch (err) {
+        jsonResponse(res, { error: err.message }, 500);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // GET /api/wall-e/agent/paired
+  if (p === '/api/wall-e/agent/paired' && m === 'GET') {
+    try {
+      const agentApi = require('./channels/agent-api');
+      const data = agentApi.listPairedAgents();
+      jsonResponse(res, { data });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // POST /api/wall-e/agent/pair
+  if (p === '/api/wall-e/agent/pair' && m === 'POST') {
+    readBody(req).then(body => {
+      try {
+        if (!body.agent_id || !body.endpoint || !body.owner) {
+          jsonResponse(res, { error: 'agent_id, endpoint, and owner are required' }, 400);
+          return;
+        }
+        const agentApi = require('./channels/agent-api');
+        agentApi.pairAgent(body.agent_id, body.endpoint, body.owner);
+        jsonResponse(res, { data: { ok: true } });
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 400);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // POST /api/wall-e/agent/unpair
+  if (p === '/api/wall-e/agent/unpair' && m === 'POST') {
+    readBody(req).then(body => {
+      try {
+        if (!body.agent_id) {
+          jsonResponse(res, { error: 'agent_id is required' }, 400);
+          return;
+        }
+        const agentApi = require('./channels/agent-api');
+        agentApi.unpairAgent(body.agent_id);
+        jsonResponse(res, { data: { ok: true } });
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 400);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // GET /api/wall-e/exchanges
+  if (p === '/api/wall-e/exchanges' && m === 'GET') {
+    if (!brain) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    try {
+      const limit = parseLimit(params, 50);
+      const data = brain.listExchanges({ limit });
+      jsonResponse(res, { data });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // --- Persona Management ---
+
+  // GET /api/wall-e/personas
+  if (p === '/api/wall-e/personas' && m === 'GET') {
+    if (!brain) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    try {
+      const data = brain.listPersonas();
+      jsonResponse(res, { data });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // POST /api/wall-e/personas
+  if (p === '/api/wall-e/personas' && m === 'POST') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        if (!body.person_id) {
+          jsonResponse(res, { error: 'person_id is required' }, 400);
+          return;
+        }
+        // Check if persona exists for this person — update if so, create if not
+        const existing = brain.getPersonaForPerson(body.person_id);
+        if (existing) {
+          const updates = {};
+          if (body.persona_type !== undefined) updates.persona_type = body.persona_type;
+          if (body.sharing_rules !== undefined) updates.sharing_rules = body.sharing_rules;
+          if (body.tone !== undefined) updates.tone = body.tone;
+          if (body.boundaries !== undefined) updates.boundaries = body.boundaries;
+          if (body.examples !== undefined) updates.examples = body.examples;
+          if (Object.keys(updates).length > 0) {
+            brain.updatePersona(existing.id, updates);
+          }
+          jsonResponse(res, { data: { id: existing.id, updated: true } });
+        } else {
+          const result = brain.insertPersona(body);
+          jsonResponse(res, { data: { id: result.id, created: true } }, 201);
+        }
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 400);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // --- Skills Management ---
+
+  // GET /api/wall-e/skills
+  if (p === '/api/wall-e/skills' && m === 'GET') {
+    if (!brain) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    try {
+      const enabled = params.get('enabled');
+      const filter = enabled !== null ? { enabled: parseInt(enabled) } : {};
+      const data = brain.listSkills(filter);
+      jsonResponse(res, { data });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // POST /api/wall-e/skills
+  if (p === '/api/wall-e/skills' && m === 'POST') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        if (!body.name) {
+          jsonResponse(res, { error: 'name is required' }, 400);
+          return;
+        }
+        const result = brain.insertSkill({
+          name: body.name,
+          description: body.description,
+          tool_definitions: body.tool_definitions ? (typeof body.tool_definitions === 'string' ? body.tool_definitions : JSON.stringify(body.tool_definitions)) : undefined,
+          trigger_type: body.trigger_type,
+          trigger_config: body.trigger_config ? (typeof body.trigger_config === 'string' ? body.trigger_config : JSON.stringify(body.trigger_config)) : undefined,
+          prompt_template: body.prompt_template,
+        });
+        jsonResponse(res, { data: { id: result.id } }, 201);
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 400);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // GET /api/wall-e/skills/suggestions
+  if (p === '/api/wall-e/skills/suggestions' && m === 'GET') {
+    try {
+      const { suggestSkillsFromClaudeCode } = require('./skills/claude-code-reader');
+      const data = suggestSkillsFromClaudeCode();
+      jsonResponse(res, { data });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // PUT /api/wall-e/skills/:id
+  const skillUpdateMatch = p.match(/^\/api\/wall-e\/skills\/([^/]+)$/);
+  if (skillUpdateMatch && m === 'PUT') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        const updates = {};
+        if (body.name !== undefined) updates.name = body.name;
+        if (body.description !== undefined) updates.description = body.description;
+        if (body.tool_definitions !== undefined) updates.tool_definitions = typeof body.tool_definitions === 'string' ? body.tool_definitions : JSON.stringify(body.tool_definitions);
+        if (body.trigger_type !== undefined) updates.trigger_type = body.trigger_type;
+        if (body.trigger_config !== undefined) updates.trigger_config = typeof body.trigger_config === 'string' ? body.trigger_config : JSON.stringify(body.trigger_config);
+        if (body.prompt_template !== undefined) updates.prompt_template = body.prompt_template;
+        if (body.enabled !== undefined) updates.enabled = body.enabled;
+        brain.updateSkill(skillUpdateMatch[1], updates);
+        jsonResponse(res, { data: { ok: true } });
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 400);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // POST /api/wall-e/skills/:id/run — tries DB skill first, then installed (filesystem) skill
+  const skillRunMatch = p.match(/^\/api\/wall-e\/skills\/([^/]+)\/run$/);
+  if (skillRunMatch && m === 'POST') {
+    // Try DB-based skill by ID first
+    if (brain && ensureBrainInit()) {
+      const dbSkill = brain.getSkill(skillRunMatch[1]);
+      if (dbSkill) {
+        const { runSkill } = require('./skills/skill-executor');
+        runSkill(dbSkill).then(result => {
+          jsonResponse(res, { data: result });
+        }).catch(e => {
+          jsonResponse(res, { error: e.message }, 500);
+        });
+        return true;
+      }
+    }
+    // Fall through to installed (filesystem) skill by name
+    const skillName = skillRunMatch[1];
+    const { getSkillByName: getInstalledSkill } = require('./skills/skill-loader');
+    const installedSkill = getInstalledSkill(skillName);
+    if (!installedSkill) return jsonResponse(res, { error: 'Skill not found: ' + skillName }, 404), true;
+
+    readBody(req).then(async body => {
+      const startTime = Date.now();
+      try {
+        if (installedSkill.execution === 'script') {
+          const { execFileSync } = require('child_process');
+          const entryPath = require('path').resolve(installedSkill.dir, installedSkill.entry || 'run.js');
+          const scriptArgs = body.args || installedSkill.args || [];
+          const env = {
+            ...process.env,
+            WALL_E_SKILL_CONFIG: JSON.stringify(body.config || installedSkill.config || {}),
+            WALL_E_SKILL_DIR: installedSkill.dir,
+            WALL_E_DATA_DIR: brain ? brain.DATA_DIR : '',
+          };
+          const output = execFileSync('node', [entryPath, ...scriptArgs], {
+            env,
+            timeout: 120000,
+            encoding: 'utf8',
+            maxBuffer: 5 * 1024 * 1024,
+          });
+          const duration_ms = Date.now() - startTime;
+          jsonResponse(res, { data: { result: output.trim(), duration_ms } });
+        } else {
+          const duration_ms = Date.now() - startTime;
+          jsonResponse(res, { data: { mode: 'agent', instructions: installedSkill.body, config: installedSkill.config, duration_ms } });
+        }
+      } catch (e) {
+        const duration_ms = Date.now() - startTime;
+        jsonResponse(res, { error: e.message, data: { duration_ms } }, 500);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // GET /api/wall-e/skills/:id/executions
+  const skillExecMatch = p.match(/^\/api\/wall-e\/skills\/([^/]+)\/executions$/);
+  if (skillExecMatch && m === 'GET') {
+    if (!brain) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    try {
+      const limit = parseLimit(params, 20);
+      const data = brain.listSkillExecutions({ skill_id: skillExecMatch[1], limit });
+      jsonResponse(res, { data });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // --- Installed Skills (filesystem-based) ---
+
+  // GET /api/wall-e/skills/installed
+  if (p === '/api/wall-e/skills/installed' && m === 'GET') {
+    try {
+      const { loadAllSkills } = require('./skills/skill-loader');
+      const data = loadAllSkills().map(s => ({
+        name: s.name,
+        description: s.description,
+        version: s.version,
+        execution: s.execution,
+        entry: s.entry,
+        args: s.args,
+        author: s.author,
+        trigger: s.trigger,
+        config: s.config,
+        tags: s.tags,
+        permissions: s.permissions,
+        source: s.source,
+      }));
+      jsonResponse(res, { data });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // GET /api/wall-e/skills/search?q=...
+  if (p === '/api/wall-e/skills/search' && m === 'GET') {
+    try {
+      const { searchSkills } = require('./skills/skill-loader');
+      const q = params.get('q') || '';
+      const data = searchSkills(q).map(s => ({
+        name: s.name,
+        description: s.description,
+        version: s.version,
+        execution: s.execution,
+        tags: s.tags,
+        source: s.source,
+      }));
+      jsonResponse(res, { data });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // --- Slack Ingest ---
+
+  // GET /api/wall-e/slack-ingest/progress
+  if (p === '/api/wall-e/slack-ingest/progress' && m === 'GET') {
+    try {
+      const slackIngest = require('./skills/slack-ingest');
+      const data = slackIngest.getProgress();
+      jsonResponse(res, { data });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // POST /api/wall-e/slack-ingest/start
+  if (p === '/api/wall-e/slack-ingest/start' && m === 'POST') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    try {
+      const slackIngest = require('./skills/slack-ingest');
+      // Reset checkpoint to start fresh
+      slackIngest.resetCheckpoint();
+      // Enable the skill
+      const skill = brain.getSkillByName('ingest-slack-history');
+      if (skill) {
+        brain.updateSkill(skill.id, { enabled: 1 });
+      }
+      jsonResponse(res, { data: { ok: true, message: 'Slack ingest started' } });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // POST /api/wall-e/slack-ingest/reset
+  if (p === '/api/wall-e/slack-ingest/reset' && m === 'POST') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    try {
+      const slackIngest = require('./skills/slack-ingest');
+      slackIngest.resetCheckpoint();
+      jsonResponse(res, { data: { ok: true, message: 'Checkpoint reset' } });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // --- Briefing Items ---
+
+  // GET /api/wall-e/briefing-items
+  if (p === '/api/wall-e/briefing-items' && m === 'GET') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    try {
+      const skill = params.get('skill') || undefined;
+      const status = params.get('status') || undefined;
+      const limit = parseLimit(params, 100);
+      const data = brain.listBriefingItems({ skill, status, limit });
+      // Un-snooze expired items in the response
+      const now = new Date().toISOString();
+      for (const item of data) {
+        if (item.status === 'snoozed' && item.snooze_until && item.snooze_until <= now) {
+          brain.updateBriefingItem(item.id, { status: 'open', snooze_until: null });
+          item.status = 'open';
+          item.snooze_until = null;
+        }
+      }
+      jsonResponse(res, { data });
+    } catch (e) {
+      jsonResponse(res, { error: e.message }, 500);
+    }
+    return true;
+  }
+
+  // PUT /api/wall-e/briefing-items/:id
+  const briefingItemMatch = p.match(/^\/api\/wall-e\/briefing-items\/([^/]+)$/);
+  if (briefingItemMatch && m === 'PUT') {
+    if (!brain || !ensureBrainInit()) return jsonResponse(res, { error: 'Brain module not available' }, 503), true;
+    readBody(req).then(body => {
+      try {
+        const updates = {};
+        if (body.status !== undefined) {
+          updates.status = body.status;
+          if (body.status === 'done' || body.status === 'dismissed') {
+            updates.resolved_at = new Date().toISOString();
+          }
+        }
+        if (body.notes !== undefined) updates.notes = body.notes;
+        if (body.urgency !== undefined) updates.urgency = body.urgency;
+        if (body.snooze_until !== undefined) {
+          updates.snooze_until = body.snooze_until;
+          if (body.snooze_until) updates.status = 'snoozed';
+        }
+        brain.updateBriefingItem(briefingItemMatch[1], updates);
+        jsonResponse(res, { data: { ok: true } });
+      } catch (e) {
+        jsonResponse(res, { error: e.message }, 400);
+      }
+    }).catch(e => jsonResponse(res, { error: e.message }, 400));
+    return true;
+  }
+
+  // No matching route under /api/wall-e
+  jsonResponse(res, { error: 'Not found' }, 404);
+  return true;
+}
+
+// Allow overriding the read DB (for testing)
+function _setReadDb(db) {
+  readDb = db;
+}
+
+function _setBrain(b) {
+  brain = b;
+}
+
+module.exports = {
+  handleWalleApi,
+  // Individual handlers for testing
+  getStatus,
+  getKnowledgeList,
+  getMemoriesList,
+  getPeopleList,
+  getTimeline,
+  getQuestionsList,
+  getStats,
+  getBrief,
+  // Test helpers
+  _setReadDb,
+  _setBrain,
+};