dev-mcp-server 0.0.2 → 1.0.0

package/src/api/routes/query.js

@@ -3,6 +3,11 @@ const router = express.Router();
 const { QueryEngine, QUERY_MODES } = require('../../core/queryEngine');
 const logger = require('../../utils/logger');
 
+/**
+ * POST /api/query
+ * General question — auto-detects mode
+ * Body: { question, topK?, filter? }
+ */
 router.post('/', async (req, res) => {
     const { question, topK, filter, mode } = req.body;
 
@@ -19,6 +24,11 @@ router.post('/', async (req, res) => {
     }
 });
 
+/**
+ * POST /api/query/debug
+ * "Why is this failing?"
+ * Body: { error, stackTrace?, topK? }
+ */
 router.post('/debug', async (req, res) => {
     const { error, stackTrace, question, topK } = req.body;
 
@@ -40,6 +50,11 @@ router.post('/debug', async (req, res) => {
     }
 });
 
+/**
+ * POST /api/query/usage
+ * "Where is this used?"
+ * Body: { symbol, topK? }
+ */
 router.post('/usage', async (req, res) => {
     const { symbol, topK } = req.body;
 
@@ -56,6 +71,11 @@ router.post('/usage', async (req, res) => {
     }
 });
 
+/**
+ * POST /api/query/impact
+ * "If I change this, what breaks?"
+ * Body: { target, changeDescription?, topK? }
+ */
 router.post('/impact', async (req, res) => {
     const { target, changeDescription, topK } = req.body;
 
@@ -72,6 +92,10 @@ router.post('/impact', async (req, res) => {
     }
 });
 
+/**
+ * POST /api/query/stream
+ * Streaming version of general query (Server-Sent Events)
+ */
 router.post('/stream', async (req, res) => {
     const { question, topK, mode } = req.body;
 

package/src/api/routes/sessions.js

@@ -0,0 +1,54 @@
+const express = require('express');
+const router = express.Router();
+const sessionManager = require('../../sessions/sessionManager');
+
+/** GET /api/sessions — list all sessions */
+router.get('/', (req, res) => {
+  res.json({ sessions: sessionManager.list() });
+});
+
+/** POST /api/sessions — create a new session */
+router.post('/', (req, res) => {
+  const session = sessionManager.create(req.body);
+  res.status(201).json({ success: true, session });
+});
+
+/** GET /api/sessions/:id — get / resume a session */
+router.get('/:id', (req, res) => {
+  try {
+    const session = sessionManager.resume(req.params.id);
+    res.json(session);
+  } catch (err) {
+    res.status(404).json({ error: err.message });
+  }
+});
+
+/** POST /api/sessions/:id/messages — append a message */
+router.post('/:id/messages', (req, res) => {
+  try {
+    const session = sessionManager.addMessage(req.params.id, req.body);
+    res.json({ success: true, messageCount: session.messages.length });
+  } catch (err) {
+    res.status(404).json({ error: err.message });
+  }
+});
+
+/** GET /api/sessions/:id/export — export as markdown */
+router.get('/:id/export', (req, res) => {
+  try {
+    const md = sessionManager.exportMarkdown(req.params.id);
+    res.setHeader('Content-Type', 'text/markdown');
+    res.setHeader('Content-Disposition', `attachment; filename="session-${req.params.id}.md"`);
+    res.send(md);
+  } catch (err) {
+    res.status(404).json({ error: err.message });
+  }
+});
+
+/** DELETE /api/sessions/:id */
+router.delete('/:id', (req, res) => {
+  const deleted = sessionManager.delete(req.params.id);
+  res.json({ success: deleted });
+});
+
+module.exports = router;

package/src/api/routes/tasks.js

@@ -0,0 +1,67 @@
+const express = require('express');
+const router = express.Router();
+const { TaskManager, STATUS, PRIORITY } = require('../../tasks/taskManager');
+
+/** GET /api/tasks */
+router.get('/', (req, res) => {
+  const { status, priority, tags, assignee, includeDone } = req.query;
+  const tasks = TaskManager.list({
+    status, priority,
+    tags: tags ? tags.split(',') : undefined,
+    assignee,
+    includeDone: includeDone === 'true',
+  });
+  res.json({ tasks, stats: TaskManager.getStats() });
+});
+
+/** POST /api/tasks */
+router.post('/', (req, res) => {
+  try {
+    const task = TaskManager.create(req.body);
+    res.status(201).json({ success: true, task });
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+/** GET /api/tasks/:id */
+router.get('/:id', (req, res) => {
+  const task = TaskManager.get(parseInt(req.params.id));
+  if (!task) return res.status(404).json({ error: 'Task not found' });
+  res.json(task);
+});
+
+/** PATCH /api/tasks/:id */
+router.patch('/:id', (req, res) => {
+  try {
+    const task = TaskManager.update(parseInt(req.params.id), req.body);
+    res.json({ success: true, task });
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+/** POST /api/tasks/:id/notes */
+router.post('/:id/notes', (req, res) => {
+  const { note } = req.body;
+  if (!note) return res.status(400).json({ error: 'note is required' });
+  try {
+    const task = TaskManager.addNote(parseInt(req.params.id), note);
+    res.json({ success: true, task });
+  } catch (err) {
+    res.status(400).json({ error: err.message });
+  }
+});
+
+/** DELETE /api/tasks/:id */
+router.delete('/:id', (req, res) => {
+  const deleted = TaskManager.delete(parseInt(req.params.id));
+  res.json({ success: deleted });
+});
+
+/** GET /api/tasks/meta/constants */
+router.get('/meta/constants', (req, res) => {
+  res.json({ STATUS, PRIORITY });
+});
+
+module.exports = router;

package/src/api/routes/tools.js

@@ -0,0 +1,85 @@
+const express = require('express');
+const router = express.Router();
+const BashTool = require('../../tools/BashTool');
+const GrepTool = require('../../tools/GrepTool');
+const logger = require('../../utils/logger');
+
+/** POST /api/tools/bash  — execute a shell command */
+router.post('/bash', async (req, res) => {
+  const { command, cwd, timeout, approved } = req.body;
+  if (!command) return res.status(400).json({ error: 'command is required' });
+
+  const permission = BashTool.checkPermission(command);
+  if (permission === 'dangerous') {
+    return res.status(403).json({ error: 'Command blocked: dangerous pattern detected', permission });
+  }
+  if (permission === 'needs-approval' && !approved) {
+    return res.status(202).json({ needsApproval: true, command, permission,
+      message: 'Set approved:true in body to execute, or grant permission via /api/tools/bash/permit' });
+  }
+
+  try {
+    const result = await BashTool.execute(command, { cwd, timeout, approved: true });
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** POST /api/tools/bash/permit  — grant permission for a command */
+router.post('/bash/permit', (req, res) => {
+  const { command, level } = req.body;
+  if (!command) return res.status(400).json({ error: 'command is required' });
+  BashTool.grantPermission(command, level || 'session');
+  res.json({ success: true, command, level: level || 'session' });
+});
+
+/** GET /api/tools/grep  — search codebase */
+router.get('/grep', async (req, res) => {
+  const { pattern, cwd, glob, ignoreCase, maxResults, contextLines, literal } = req.query;
+  if (!pattern) return res.status(400).json({ error: 'pattern is required' });
+
+  try {
+    const result = await GrepTool.search(pattern, {
+      cwd, glob, ignoreCase: ignoreCase === 'true',
+      maxResults: parseInt(maxResults) || 50,
+      contextLines: parseInt(contextLines) || 2,
+      literal: literal === 'true',
+    });
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** GET /api/tools/grep/definitions/:symbol  — find symbol definitions */
+router.get('/grep/definitions/:symbol', async (req, res) => {
+  try {
+    const matches = await GrepTool.findDefinitions(req.params.symbol, req.query.cwd);
+    res.json({ symbol: req.params.symbol, matches, count: matches.length });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** GET /api/tools/grep/imports/:module  — find all imports of a module */
+router.get('/grep/imports/:module', async (req, res) => {
+  try {
+    const result = await GrepTool.findImports(req.params.module, req.query.cwd);
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** GET /api/tools/grep/todos  — find all TODO/FIXME comments */
+router.get('/grep/todos', async (req, res) => {
+  try {
+    const result = await GrepTool.findTodos(req.query.cwd);
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+module.exports = router;

package/src/api/routes/v5routes.js

@@ -0,0 +1,196 @@
+'use strict';
+const express = require('express');
+const logger  = require('../../utils/logger');
+
+// ── PLUGINS ───────────────────────────────────────────────────────────────────
+const pluginsRouter = express.Router();
+const pluginManager = require('../../plugins/pluginManager');
+
+pluginsRouter.get('/', (req, res) => res.json({ plugins: pluginManager.list(), stats: pluginManager.getStats() }));
+pluginsRouter.get('/:name', (req, res) => {
+  const p = pluginManager.get(req.params.name);
+  if (!p) return res.status(404).json({ error: 'Plugin not found' });
+  res.json(p);
+});
+pluginsRouter.post('/:name/enable', (req, res) => {
+  try { res.json(pluginManager.enable(req.params.name)); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+pluginsRouter.post('/:name/disable', (req, res) => {
+  try { res.json(pluginManager.disable(req.params.name)); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+
+module.exports.pluginsRouter = pluginsRouter;
+
+// ── WORKTREES ─────────────────────────────────────────────────────────────────
+const worktreesRouter = express.Router();
+const wm = require('../../worktrees/worktreeManager');
+
+worktreesRouter.get('/', async (req, res) => {
+  try { res.json({ worktrees: await wm.list(req.query.cwd), stats: wm.getStats() }); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+worktreesRouter.post('/', async (req, res) => {
+  const { name, branch, cwd, createBranch } = req.body;
+  if (!name || !branch) return res.status(400).json({ error: 'name and branch required' });
+  try { res.status(201).json(await wm.create(name, branch, { cwd, createBranch })); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+worktreesRouter.get('/:name', (req, res) => {
+  const wt = wm.get(req.params.name);
+  if (!wt) return res.status(404).json({ error: 'Worktree not found' });
+  res.json(wt);
+});
+worktreesRouter.get('/:name/diff', async (req, res) => {
+  try { res.json(await wm.diff(req.params.name)); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+worktreesRouter.get('/:name/log', async (req, res) => {
+  try { res.json({ log: await wm.log(req.params.name, req.query.limit) }); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+worktreesRouter.post('/:name/commit', async (req, res) => {
+  try { res.json(await wm.commit(req.params.name, req.body.message)); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+worktreesRouter.delete('/:name', async (req, res) => {
+  try { res.json(await wm.remove(req.params.name, { force: req.query.force === 'true' })); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+module.exports.worktreesRouter = worktreesRouter;
+
+// ── CRON ──────────────────────────────────────────────────────────────────────
+const cronRouter = express.Router();
+const cron = require('../../cron/cronScheduler');
+
+cronRouter.get('/', (req, res) => res.json({ jobs: cron.list(), stats: cron.getStats() }));
+cronRouter.post('/', (req, res) => {
+  try { res.status(201).json(cron.create(req.body)); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+cronRouter.get('/:name', (req, res) => {
+  const job = cron.list().find(j => j.name === req.params.name);
+  if (!job) return res.status(404).json({ error: 'Job not found' });
+  res.json(job);
+});
+cronRouter.patch('/:name', (req, res) => {
+  try { res.json(cron.update(req.params.name, req.body)); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+cronRouter.post('/:name/run', async (req, res) => {
+  try { res.json(await cron.runNow(req.params.name)); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+cronRouter.get('/:name/history', (req, res) => {
+  res.json({ runs: cron.getRunHistory(req.params.name, req.query.limit) });
+});
+cronRouter.delete('/:name', (req, res) => {
+  try { res.json({ success: cron.delete(req.params.name) }); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+
+module.exports.cronRouter = cronRouter;
+
+// ── MESSAGING ─────────────────────────────────────────────────────────────────
+const messagesRouter = express.Router();
+const { MessageBus, PRIORITY } = require('../../messaging/messageBus');
+
+messagesRouter.post('/', (req, res) => {
+  try { res.status(201).json(MessageBus.send(req.body)); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+messagesRouter.post('/broadcast', (req, res) => {
+  try { res.json({ messages: MessageBus.broadcast(req.body) }); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+messagesRouter.get('/inbox/:agent', (req, res) => {
+  res.json({
+    messages: MessageBus.inbox(req.params.agent, {
+      unreadOnly: req.query.unread === 'true',
+      priority:   req.query.priority,
+      limit:      parseInt(req.query.limit) || 50,
+    }),
+  });
+});
+messagesRouter.get('/sent/:agent', (req, res) => {
+  res.json({ messages: MessageBus.sentBy(req.params.agent) });
+});
+messagesRouter.post('/:id/read', (req, res) => {
+  try { res.json(MessageBus.markRead(parseInt(req.params.id))); }
+  catch (e) { res.status(404).json({ error: e.message }); }
+});
+messagesRouter.post('/inbox/:agent/read-all', (req, res) => {
+  res.json({ read: MessageBus.markAllRead(req.params.agent) });
+});
+messagesRouter.post('/:id/reply', (req, res) => {
+  try { res.json(MessageBus.reply(parseInt(req.params.id), req.body)); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+messagesRouter.delete('/:id', (req, res) => {
+  res.json({ success: MessageBus.delete(parseInt(req.params.id)) });
+});
+messagesRouter.get('/stats/overview', (req, res) => {
+  res.json({ stats: MessageBus.getStats(), priorities: PRIORITY });
+});
+
+module.exports.messagesRouter = messagesRouter;
+
+// ── TEAM MEMORY ───────────────────────────────────────────────────────────────
+const teamMemRouter = express.Router();
+const teamMemory = require('../../memory/teamMemory');
+
+teamMemRouter.get('/', (req, res) => {
+  const entries = teamMemory.get(req.query.team || 'global', {
+    type:  req.query.type,
+    limit: parseInt(req.query.limit) || 50,
+  });
+  res.json({ entries, stats: teamMemory.getStats() });
+});
+teamMemRouter.post('/', (req, res) => {
+  try { res.status(201).json(teamMemory.add(req.body)); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+teamMemRouter.get('/search', (req, res) => {
+  if (!req.query.q) return res.status(400).json({ error: 'q required' });
+  res.json({ results: teamMemory.search(req.query.q, req.query.team) });
+});
+teamMemRouter.get('/teams', (req, res) => {
+  res.json({ teams: teamMemory.listTeams() });
+});
+teamMemRouter.delete('/:id', (req, res) => {
+  res.json({ success: teamMemory.delete(req.params.id) });
+});
+teamMemRouter.delete('/', (req, res) => {
+  if (!req.query.team) return res.status(400).json({ error: 'team query param required' });
+  teamMemory.clearTeam(req.query.team);
+  res.json({ success: true });
+});
+
+module.exports.teamMemRouter = teamMemRouter;
+
+// ── CONTEXT VISUALIZER ────────────────────────────────────────────────────────
+const contextVizRouter = express.Router();
+const contextVisualizer = require('../../context/contextVisualizer');
+
+contextVizRouter.post('/visualize', (req, res) => {
+  const { query, mode, topK, team } = req.body;
+  if (!query) return res.status(400).json({ error: 'query required' });
+  try {
+    const viz = contextVisualizer.visualize(query, { mode, topK, team });
+    res.json(viz);
+  } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+contextVizRouter.post('/visualize/text', (req, res) => {
+  const { query, mode, topK } = req.body;
+  if (!query) return res.status(400).json({ error: 'query required' });
+  try {
+    const viz  = contextVisualizer.visualize(query, { mode, topK });
+    const text = contextVisualizer.format(viz);
+    res.type('text/plain').send(text);
+  } catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+module.exports.contextVizRouter = contextVizRouter;

package/src/api/server.js

@@ -1,29 +1,79 @@
-const path = require('path');
-require('dotenv').config({ path: path.resolve(process.cwd(), '.env') });
+require('dotenv').config();
 const express = require('express');
 const cors = require('cors');
 const morgan = require('morgan');
 const logger = require('../utils/logger');
-const indexer = require('../core/indexer');
+const dreamer = require('../agents/dreamer');
+const improver = require('../agents/improver');
+const cronScheduler = require('../cron/cronScheduler');
+const pluginManager = require('../plugins/pluginManager');
+const llm = require('../utils/llmClient');
 const store = require('../storage/store');
 
+// Routes
 const ingestRoutes = require('./routes/ingest');
 const queryRoutes = require('./routes/query');
 const knowledgeRoutes = require('./routes/knowledge');
+const gitRoutes = require('./routes/git');
+const toolsRoutes = require('./routes/tools');
+const memoryRoutes = require('./routes/memory');
+const tasksRoutes = require('./routes/tasks');
+const sessionsRoutes = require('./routes/sessions');
+const plannerRoutes = require('./routes/planner');
+const agentsRoutes = require('./routes/agents');
+const pipelinesRoutes = require('./routes/pipelines');
+const { skillsRouter, lspRouter, filesRouter, monitorRouter, convRouter, watcherRouter } = require('./routes/newRoutes');
+const { toolsRegistryRouter, promptsRouter, compactorRouter } = require('./routes/extras');
+const { pluginsRouter, worktreesRouter, cronRouter, messagesRouter, teamMemRouter, contextVizRouter } = require('./routes/v5routes');
 
 const app = express();
 const PORT = process.env.PORT || 3000;
 
+// ── Middleware ────────────────────────────────────────────────
 app.use(cors());
 app.use(express.json({ limit: '10mb' }));
 app.use(morgan('dev', {
     stream: { write: (msg) => logger.info(msg.trim()) },
 }));
 
+// ── Routes ────────────────────────────────────────────────────
 app.use('/api/ingest', ingestRoutes);
 app.use('/api/query', queryRoutes);
 app.use('/api/knowledge', knowledgeRoutes);
+app.use('/api/git', gitRoutes);
+app.use('/api/tools', toolsRoutes);
+app.use('/api/memory', memoryRoutes);
+app.use('/api/tasks', tasksRoutes);
+app.use('/api/sessions', sessionsRoutes);
+app.use('/api', plannerRoutes); // /api/plan, /api/cost
+app.use('/api/agents', agentsRoutes);
+app.use('/api/pipelines', pipelinesRoutes);
+app.use('/api/skills', skillsRouter);
+app.use('/api/lsp', lspRouter);
+app.use('/api/files', filesRouter);
+app.use('/api/monitor', monitorRouter);
+app.use('/api/chat', convRouter);
+app.use('/api/watcher', watcherRouter);
+app.use('/api/registry', toolsRegistryRouter);
+app.use('/api/prompts', promptsRouter);
+app.use('/api/compact', compactorRouter);
+app.use('/api/plugins', pluginsRouter);
+app.use('/api/worktrees', worktreesRouter);
+app.use('/api/cron', cronRouter);
+app.use('/api/messages', messagesRouter);
+app.use('/api/team-memory', teamMemRouter);
+app.use('/api/context', contextVizRouter);
+
+// ── Dashboard (single-file HTML UI) ──────────────────────────────────────────
+const path = require('path');
+app.get('/dashboard', (req, res) => {
+    res.sendFile(path.join(__dirname, '../dashboard/index.html'));
+});
+
+// ── LLM provider info ────────────────────────────────────────────────────────
+app.get('/api/llm/info', (req, res) => res.json(llm.getInfo()));
 
+// ── Health check ──────────────────────────────────────────────
 app.get('/health', (req, res) => {
     const stats = store.getStats();
     res.json({
@@ -34,11 +84,12 @@ app.get('/health', (req, res) => {
     });
 });
 
+// ── Root info ─────────────────────────────────────────────────
 app.get('/', (req, res) => {
     res.json({
         name: 'Dev MCP Server — Model Context Platform',
         version: '1.0.0',
-        description: 'AI that understands YOUR codebase',
+        description: '45 tools · 10 agents · 10 teams · Dreamer · Compactor · Prompt Engineering · Plugins · Cron · Worktrees · Messaging',
         endpoints: {
             health: 'GET /health',
             ingest: {
@@ -61,31 +112,108 @@ app.get('/', (req, res) => {
                 files: 'GET /api/knowledge/files',
                 rebuild: 'POST /api/knowledge/rebuild',
             },
+            git: {
+                status: 'GET /api/git/status',
+                diff: 'GET /api/git/diff',
+                commit: 'POST /api/git/commit',
+                review: 'POST /api/git/review',
+                log: 'GET /api/git/log',
+                branches: 'GET /api/git/branches',
+            },
+            tools: {
+                bash: 'POST /api/tools/bash',
+                bashPermit: 'POST /api/tools/bash/permit',
+                grep: 'GET /api/tools/grep?pattern=<pattern>',
+                definitions: 'GET /api/tools/grep/definitions/:symbol',
+                imports: 'GET /api/tools/grep/imports/:module',
+                todos: 'GET /api/tools/grep/todos',
+            },
+            memory: {
+                list: 'GET /api/memory',
+                add: 'POST /api/memory',
+                delete: 'DELETE /api/memory/:id',
+                clear: 'DELETE /api/memory',
+            },
+            tasks: {
+                list: 'GET /api/tasks',
+                create: 'POST /api/tasks',
+                get: 'GET /api/tasks/:id',
+                update: 'PATCH /api/tasks/:id',
+                addNote: 'POST /api/tasks/:id/notes',
+                delete: 'DELETE /api/tasks/:id',
+            },
+            sessions: {
+                list: 'GET /api/sessions',
+                create: 'POST /api/sessions',
+                resume: 'GET /api/sessions/:id',
+                addMessage: 'POST /api/sessions/:id/messages',
+                export: 'GET /api/sessions/:id/export',
+                delete: 'DELETE /api/sessions/:id',
+            },
+            planner: {
+                plan: 'POST /api/plan',
+                compact: 'POST /api/plan/compact',
+                doctor: 'GET /api/plan/doctor',
+                cost: 'GET /api/cost',
+            },
         },
     });
 });
 
+// ── 404 ───────────────────────────────────────────────────────
 app.use((req, res) => {
     res.status(404).json({ error: `Route not found: ${req.method} ${req.path}` });
 });
 
+// ── Error handler ─────────────────────────────────────────────
 app.use((err, req, res, next) => {
     logger.error(`Unhandled error: ${err.message}`);
     res.status(500).json({ error: 'Internal server error', detail: err.message });
 });
 
-app.listen(PORT, () => {
+// ── Boot ──────────────────────────────────────────────────────
+app.listen(PORT, async () => {
     logger.info(`🚀 Dev MCP Server running on http://localhost:${PORT}`);
     logger.info(`📚 Knowledge base: ${store.getStats().totalDocs} documents`);
 
+    // Auto-build index if data exists
     const stats = store.getStats();
     if (stats.totalDocs > 0) {
         logger.info('🔍 Rebuilding search index...');
+        const indexer = require('../core/indexer');
         const count = indexer.build();
         logger.info(`✅ Index ready: ${count} documents`);
     } else {
         logger.info('📭 Knowledge base is empty — run: node cli.js ingest <path>');
     }
+
+    // Start the Dreamer for background cognitive work
+    if (process.env.ENABLE_DREAMER !== 'false') {
+        const intervalMin = parseInt(process.env.DREAM_INTERVAL_MINUTES) || 30;
+        dreamer.start(intervalMin);
+        logger.info(`💤 Dreamer started (every ${intervalMin} min)`);
+    }
+
+    // Start Cron Scheduler
+    if (process.env.ENABLE_CRON !== 'false') {
+        cronScheduler.start();
+        logger.info(`⏰ Cron scheduler started`);
+    }
+
+    // Load Plugins
+    const toolRegistry = require('../tools/registry');
+    await pluginManager.loadAll(app, {
+        toolRegistry,
+        store,
+        indexer: require('../core/indexer'),
+        memoryManager: require('../memory/memoryManager').MemoryManager,
+    });
+    logger.info(`🔌 Plugins: ${pluginManager.getStats().enabled} enabled`);
+    if (process.env.ENABLE_MONITOR !== 'false') {
+        const { ProactiveMonitor } = require('../monitor/proactiveMonitor');
+        ProactiveMonitor.start(process.cwd());
+        logger.info(`👁️  Proactive monitor started`);
+    }
 });
 
 module.exports = app;