dev-mcp-server 0.0.2 → 1.0.0

package/src/agents/taskDecomposer.js

@@ -0,0 +1,176 @@
+/**
+ * Breaks complex tasks into smaller, parallelizable subtasks and delegates
+ * each to the most appropriate specialist agent.
+ */
+
+const llm = require('../utils/llmClient');
+const costTracker = require('../utils/costTracker');
+const logger = require('../utils/logger');
+const indexer = require('../core/indexer');
+const contextEngineer = require('../context/contextEngineer');
+
+// Agent → what kinds of subtasks it handles
+const AGENT_CAPABILITIES = {
+    DebugAgent: ['debug', 'error', 'exception', 'crash', 'fix', 'trace', 'failing'],
+    ArchitectureAgent: ['architecture', 'structure', 'design', 'coupling', 'module', 'dependency', 'overview'],
+    SecurityAgent: ['security', 'vulnerability', 'auth', 'injection', 'xss', 'csrf', 'secret', 'token'],
+    DocumentationAgent: ['document', 'docs', 'comment', 'readme', 'api', 'explain', 'describe'],
+    RefactorAgent: ['refactor', 'clean', 'improve', 'duplicate', 'simplify', 'rewrite', 'quality'],
+    PerformanceAgent: ['performance', 'slow', 'bottleneck', 'optimize', 'memory', 'leak', 'n+1', 'query'],
+};
+
+class TaskDecomposer {
+    /**
+     * Decompose a complex task into subtasks using
+     */
+    async decompose(task, sessionId = 'default') {
+        logger.info(`[Decomposer] Decomposing: "${task.slice(0, 80)}"`);
+
+        const response = await llm.chat({
+            model: llm.model('fast'),
+            max_tokens: 800,
+            system: `You are a task decomposition engine for a developer AI system.
+Break the given task into 2-5 concrete, independent subtasks.
+Each subtask should be assigned to ONE of these agents:
+${Object.entries(AGENT_CAPABILITIES).map(([a, k]) => `- ${a}: handles ${k.slice(0, 4).join(', ')} etc.`).join('\n')}
+
+Return ONLY a JSON array:
+[{"subtask": "...", "agent": "AgentName", "priority": 1, "rationale": "..."}]
+Priority 1 = highest. No preamble, no markdown fences.`,
+            messages: [{ role: 'user', content: `Task: ${task}` }],
+        });
+
+        costTracker.record({
+            model: llm.model('fast'),
+            inputTokens: response.usage.input_tokens,
+            outputTokens: response.usage.output_tokens,
+            sessionId,
+            queryType: 'decompose',
+        });
+
+        try {
+            const subtasks = JSON.parse(response.content[0].text.trim());
+            logger.info(`[Decomposer] Generated ${subtasks.length} subtasks`);
+            return subtasks.sort((a, b) => a.priority - b.priority);
+        } catch {
+            // Fallback: single subtask routed by keyword matching
+            const agent = this._routeByKeyword(task);
+            return [{ subtask: task, agent, priority: 1, rationale: 'Keyword-based routing' }];
+        }
+    }
+
+    /**
+     * Decompose AND execute all subtasks, optionally in parallel
+     */
+    async decomposeAndRun(task, options = {}) {
+        const { parallel = false, sessionId = 'default', maxSubtasks = 4 } = options;
+
+        const subtasks = await this.decompose(task, sessionId);
+        const limited = subtasks.slice(0, maxSubtasks);
+
+        logger.info(`[Decomposer] Executing ${limited.length} subtasks (parallel=${parallel})`);
+
+        // Retrieve shared context for all subtasks up front
+        const sharedDocs = indexer.search(task, 10);
+
+        const runSubtask = async (subtask) => {
+            const agents = require('./specialists');
+            const agent = agents[subtask.agent];
+
+            if (!agent) {
+                logger.warn(`[Decomposer] Unknown agent: ${subtask.agent}, using DebugAgent`);
+                return { subtask: subtask.subtask, agent: subtask.agent, error: 'Agent not found' };
+            }
+
+            // Get subtask-specific context on top of shared context
+            const specificDocs = indexer.search(subtask.subtask, 5);
+            const allDocs = this._mergeDedupe(sharedDocs, specificDocs);
+
+            logger.info(`[Decomposer] → ${subtask.agent}: "${subtask.subtask.slice(0, 50)}"`);
+
+            try {
+                const result = await agent.run(subtask.subtask, { context: allDocs, sessionId });
+                return {
+                    subtask: subtask.subtask,
+                    agent: subtask.agent,
+                    rationale: subtask.rationale,
+                    priority: subtask.priority,
+                    result: result.answer,
+                    toolResults: result.toolResults,
+                    contextChunks: result.contextChunks,
+                };
+            } catch (err) {
+                logger.error(`[Decomposer] ${subtask.agent} failed: ${err.message}`);
+                return { subtask: subtask.subtask, agent: subtask.agent, error: err.message };
+            }
+        };
+
+        let results;
+        if (parallel) {
+            results = await Promise.all(limited.map(runSubtask));
+        } else {
+            results = [];
+            for (const subtask of limited) {
+                results.push(await runSubtask(subtask));
+            }
+        }
+
+        // Synthesize all results into a coherent final answer
+        const synthesis = await this._synthesize(task, results, sessionId);
+
+        return {
+            originalTask: task,
+            subtasks: limited,
+            results,
+            synthesis,
+            agentsUsed: [...new Set(limited.map(s => s.agent))],
+        };
+    }
+
+    /**
+     * Synthesize multiple agent results into one coherent answer
+     */
+    async _synthesize(originalTask, results, sessionId) {
+        const successful = results.filter(r => !r.error);
+        if (successful.length === 0) return 'All subtasks failed.';
+        if (successful.length === 1) return successful[0].result;
+
+        const parts = successful.map(r =>
+            `## ${r.agent} (re: ${r.subtask.slice(0, 60)})\n${r.result}`
+        ).join('\n\n---\n\n');
+
+        const response = await llm.chat({
+            model: llm.model('fast'),
+            max_tokens: 1000,
+            messages: [{
+                role: 'user',
+                content: `Original task: ${originalTask}\n\nAgent results:\n${parts}\n\nSynthesize these into ONE clear, developer-focused answer. Remove duplication. Keep all concrete details (file names, line numbers, code). Be concise.`,
+            }],
+        });
+
+        costTracker.record({
+            model: llm.model('fast'),
+            inputTokens: response.usage.input_tokens,
+            outputTokens: response.usage.output_tokens,
+            sessionId,
+            queryType: 'synthesize',
+        });
+
+        return response.content[0].text;
+    }
+
+    _routeByKeyword(task) {
+        const lower = task.toLowerCase();
+        for (const [agent, keywords] of Object.entries(AGENT_CAPABILITIES)) {
+            if (keywords.some(k => lower.includes(k))) return agent;
+        }
+        return 'DebugAgent'; // default
+    }
+
+    _mergeDedupe(a, b) {
+        const seen = new Set(a.map(d => d.id));
+        return [...a, ...b.filter(d => !seen.has(d.id))];
+    }
+}
+
+module.exports = new TaskDecomposer();

package/src/agents/teamCoordinator.js

@@ -0,0 +1,153 @@
+'use strict';
+/**
+ * 10 named agent teams covering every common dev workflow.
+ * Teams run sequentially (each agent sees prior results) or in parallel.
+ */
+
+const llm = require('../utils/llmClient');
+const costTracker = require('../utils/costTracker');
+const indexer = require('../core/indexer');
+const { MemoryManager } = require('../memory/memoryManager');
+const logger = require('../utils/logger');
+
+const TEAMS = {
+    'full-audit': {
+        desc: 'Complete codebase audit: security + performance + quality + docs',
+        agents: ['SecurityAgent', 'PerformanceAgent', 'RefactorAgent', 'DocumentationAgent'],
+        sequential: true,
+    },
+    'feature-review': {
+        desc: 'Review a new feature: architecture + security + tests + docs',
+        agents: ['ArchitectureAgent', 'SecurityAgent', 'TestAgent', 'DocumentationAgent'],
+        sequential: true,
+    },
+    'bug-triage': {
+        desc: 'Triage a production bug: debug + perf impact + doc fix',
+        agents: ['DebugAgent', 'PerformanceAgent', 'DocumentationAgent'],
+        sequential: true,
+    },
+    'onboarding': {
+        desc: 'Onboard a new developer: architecture + patterns + gotchas + tasks',
+        agents: ['ArchitectureAgent', 'DocumentationAgent', 'DebugAgent', 'PlannerAgent'],
+        sequential: false,
+    },
+    'refactor-safe': {
+        desc: 'Plan a safe refactor: architecture + refactor + tests + security check',
+        agents: ['ArchitectureAgent', 'RefactorAgent', 'TestAgent', 'SecurityAgent'],
+        sequential: true,
+    },
+    'release-prep': {
+        desc: 'Prepare a release: changelog + security + tests + deployment check',
+        agents: ['DocumentationAgent', 'SecurityAgent', 'TestAgent', 'DevOpsAgent'],
+        sequential: true,
+    },
+    'data-audit': {
+        desc: 'Audit data layer: schemas + validation + query performance + security',
+        agents: ['DataAgent', 'SecurityAgent', 'PerformanceAgent'],
+        sequential: true,
+    },
+    'ci-setup': {
+        desc: 'Set up or fix CI/CD: devops analysis + tests + linting + security',
+        agents: ['DevOpsAgent', 'TestAgent', 'SecurityAgent'],
+        sequential: true,
+    },
+    'post-mortem': {
+        desc: 'Incident post-mortem: debug root cause + perf timeline + prevention plan',
+        agents: ['DebugAgent', 'PerformanceAgent', 'PlannerAgent', 'DocumentationAgent'],
+        sequential: true,
+    },
+    'greenfield': {
+        desc: 'Plan a new feature or service from scratch: architecture + security + plan',
+        agents: ['ArchitectureAgent', 'SecurityAgent', 'PlannerAgent', 'TestAgent'],
+        sequential: true,
+    },
+};
+
+class TeamCoordinator {
+    async runTeam(teamName, task, opts = {}) {
+        const team = TEAMS[teamName];
+        if (!team) throw new Error(`Unknown team: ${teamName}. Available: ${Object.keys(TEAMS).join(', ')}`);
+        return this._run(team, task, { ...opts, teamName });
+    }
+
+    async runCustomTeam(agentNames, task, opts = {}) {
+        return this._run({ agents: agentNames, sequential: opts.sequential !== false, desc: 'Custom team' }, task, { ...opts, teamName: 'custom' });
+    }
+
+    async autoRun(task, opts = {}) {
+        const name = this._selectTeam(task);
+        logger.info(`[Team] Auto-selected: ${name}`);
+        return this.runTeam(name, task, opts);
+    }
+
+    async _run(team, task, opts = {}) {
+        const { sessionId = 'default', teamName = 'custom' } = opts;
+        const agents = require('./specialists');
+        const sharedCtx = indexer.search(task, 12);
+        const memories = MemoryManager.getRelevant(task, 5);
+        const memCtx = MemoryManager.formatAsContext(memories);
+
+        const results = [];
+        let priorSummary = '';
+
+        const runAgent = async (agentName, idx) => {
+            const agent = agents[agentName];
+            if (!agent) return { agent: agentName, error: 'Not found' };
+            const taskWithPrior = team.sequential && priorSummary
+                ? `${task}\n\n## Prior agent findings — build on these, don't repeat:\n${priorSummary}`
+                : task;
+            logger.info(`[Team:${teamName}] [${idx + 1}/${team.agents.length}] ${agentName}`);
+            try {
+                const r = await agent.run(taskWithPrior, { context: sharedCtx, extraSystem: memCtx, sessionId });
+                if (team.sequential) priorSummary += `\n\n### ${agentName}:\n${r.answer.slice(0, 600)}`;
+                return { agent: agentName, answer: r.answer, loops: r.loops, tools: r.toolResults?.length || 0 };
+            } catch (err) {
+                logger.error(`[Team:${teamName}] ${agentName} failed: ${err.message}`);
+                return { agent: agentName, error: err.message };
+            }
+        };
+
+        if (team.sequential) {
+            for (let i = 0; i < team.agents.length; i++) results.push(await runAgent(team.agents[i], i));
+        } else {
+            results.push(...await Promise.all(team.agents.map((a, i) => runAgent(a, i))));
+        }
+
+        const report = await this._consolidate(task, results, teamName, sessionId);
+        return { team: teamName, task, results, report, sequential: team.sequential, agentsRun: team.agents };
+    }
+
+    async _consolidate(task, results, teamName, sessionId) {
+        const successful = results.filter(r => !r.error);
+        if (!successful.length) return 'All agents failed.';
+        if (successful.length === 1) return successful[0].answer;
+
+        const parts = successful.map(r => `### ${r.agent}\n${r.answer}`).join('\n\n---\n\n');
+        const response = await llm.chat({
+            model: llm.model('fast'), max_tokens: 1200,
+            messages: [{ role: 'user', content: `Consolidate this multi-agent team report into a final developer summary.\n\nTask: ${task}\nTeam: ${teamName}\n\n${parts}\n\nWrite:\n## Executive Summary (3-4 sentences)\n## Critical Findings (numbered, most important first)\n## Action Items (concrete next steps)\n## Agent Breakdown (which agent found what)\n\nBe specific. Include file names and line references. No fluff.` }],
+        });
+        costTracker.record({ model: llm.model('fast'), inputTokens: response.usage.input_tokens, outputTokens: response.usage.output_tokens, sessionId, queryType: 'team-consolidate' });
+        return response.content[0].text;
+    }
+
+    _selectTeam(task) {
+        const t = task.toLowerCase();
+        if (/incident|outage|down|crash|post.?mortem/i.test(t)) return 'post-mortem';
+        if (/bug|error|exception|fail|crash/i.test(t)) return 'bug-triage';
+        if (/release|deploy|ship|version|changelog/i.test(t)) return 'release-prep';
+        if (/onboard|new dev|understand|explain codebase/i.test(t)) return 'onboarding';
+        if (/refactor|clean|restructure/i.test(t)) return 'refactor-safe';
+        if (/data|schema|model|database|query/i.test(t)) return 'data-audit';
+        if (/ci|cd|pipeline|docker|deploy/i.test(t)) return 'ci-setup';
+        if (/new (feature|service|module|system)/i.test(t)) return 'greenfield';
+        if (/audit|scan|review all|security/i.test(t)) return 'full-audit';
+        return 'feature-review';
+    }
+
+    getTeams() {
+        return Object.entries(TEAMS).map(([name, t]) => ({ name, description: t.desc, agents: t.agents, sequential: t.sequential }));
+    }
+}
+
+module.exports = new TeamCoordinator();

package/src/api/routes/agents.js

@@ -0,0 +1,172 @@
+const express = require('express');
+const router = express.Router();
+const specialists = require('../../agents/specialists');
+const taskDecomposer = require('../../agents/taskDecomposer');
+const teamCoordinator = require('../../agents/teamCoordinator');
+const dreamer = require('../../agents/dreamer');
+const improver = require('../../agents/improver');
+const indexer = require('../../core/indexer');
+const logger = require('../../utils/logger');
+
+/** POST /api/agents/:name — run a specialist agent directly */
+router.post('/:name', async (req, res) => {
+  const { name } = req.params;
+  const { task, topK = 8, sessionId } = req.body;
+  if (!task) return res.status(400).json({ error: 'task is required' });
+
+  const agentKey = Object.keys(specialists).find(
+    k => k.toLowerCase() === name.toLowerCase() || k.toLowerCase().replace('agent', '') === name.toLowerCase()
+  );
+  const agent = specialists[agentKey];
+  if (!agent) {
+    return res.status(404).json({
+      error: `Agent not found: ${name}`,
+      available: Object.keys(specialists),
+    });
+  }
+
+  try {
+    const context = indexer.search(task, topK);
+    const result = await agent.run(task, { context, sessionId });
+    res.json(result);
+  } catch (err) {
+    logger.error(`Agent ${name} error: ${err.message}`);
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** GET /api/agents — list all available agents */
+router.get('/', (req, res) => {
+  res.json({
+    agents: Object.keys(specialists).map(name => ({
+      name,
+      role: specialists[name].role,
+      model: specialists[name].model,
+      stats: specialists[name].getStats(),
+    })),
+  });
+});
+
+/** POST /api/agents/:name/reset — reset agent history */
+router.post('/:name/reset', (req, res) => {
+  const agent = specialists[req.params.name];
+  if (!agent) return res.status(404).json({ error: 'Agent not found' });
+  agent.reset();
+  res.json({ success: true });
+});
+
+// ── DECOMPOSER ──────────────────────────────────────────────────────────────────
+
+/** POST /api/agents/decompose/run — decompose and run a complex task */
+router.post('/decompose/run', async (req, res) => {
+  const { task, parallel = false, sessionId, maxSubtasks = 4 } = req.body;
+  if (!task) return res.status(400).json({ error: 'task is required' });
+  try {
+    const result = await taskDecomposer.decomposeAndRun(task, { parallel, sessionId, maxSubtasks });
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** POST /api/agents/decompose/plan — decompose only, no execution */
+router.post('/decompose/plan', async (req, res) => {
+  const { task, sessionId } = req.body;
+  if (!task) return res.status(400).json({ error: 'task is required' });
+  try {
+    const subtasks = await taskDecomposer.decompose(task, sessionId);
+    res.json({ task, subtasks });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// ── TEAMS ───────────────────────────────────────────────────────────────────────
+
+/** GET /api/agents/teams/list */
+router.get('/teams/list', (req, res) => {
+  res.json({ teams: teamCoordinator.getAvailableTeams() });
+});
+
+/** POST /api/agents/teams/:name — run a named team */
+router.post('/teams/:name', async (req, res) => {
+  const { task, sessionId } = req.body;
+  if (!task) return res.status(400).json({ error: 'task is required' });
+  try {
+    const result = await teamCoordinator.runTeam(req.params.name, task, { sessionId });
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** POST /api/agents/teams/auto — auto-select and run the best team */
+router.post('/teams/auto', async (req, res) => {
+  const { task, sessionId } = req.body;
+  if (!task) return res.status(400).json({ error: 'task is required' });
+  try {
+    const result = await teamCoordinator.autoRun(task, { sessionId });
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+/** POST /api/agents/teams/custom — run a custom team */
+router.post('/teams/custom', async (req, res) => {
+  const { agents: agentNames, task, sessionId, sequential = true } = req.body;
+  if (!task || !agentNames?.length) return res.status(400).json({ error: 'task and agents[] are required' });
+  try {
+    const result = await teamCoordinator.runCustomTeam(agentNames, task, { sessionId, sequential });
+    res.json(result);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// ── DREAMER ─────────────────────────────────────────────────────────────────────
+
+/** GET /api/agents/dreamer/status */
+router.get('/dreamer/status', (req, res) => {
+  res.json(dreamer.getStatus());
+});
+
+/** POST /api/agents/dreamer/start — start background dreaming */
+router.post('/dreamer/start', (req, res) => {
+  const { intervalMinutes = 30 } = req.body;
+  dreamer.start(intervalMinutes);
+  res.json({ success: true, message: `Dreamer started (every ${intervalMinutes} min)` });
+});
+
+/** POST /api/agents/dreamer/stop */
+router.post('/dreamer/stop', (req, res) => {
+  dreamer.stop();
+  res.json({ success: true });
+});
+
+/** POST /api/agents/dreamer/now — run a dream cycle immediately */
+router.post('/dreamer/now', async (req, res) => {
+  try {
+    const result = await dreamer.dreamNow();
+    res.json({ success: true, result });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// ── IMPROVER ────────────────────────────────────────────────────────────────────
+
+/** GET /api/agents/improver/summary */
+router.get('/improver/summary', (req, res) => {
+  res.json(improver.getSummary());
+});
+
+/** POST /api/agents/improver/feedback */
+router.post('/improver/feedback', (req, res) => {
+  const { queryId, rating, comment } = req.body;
+  if (!queryId || rating === undefined) return res.status(400).json({ error: 'queryId and rating required' });
+  const entry = improver.recordFeedback(queryId, rating, comment);
+  res.json({ success: true, entry });
+});
+
+module.exports = router;

package/src/api/routes/extras.js

@@ -0,0 +1,115 @@
+'use strict';
+const express = require('express');
+const logger  = require('../../utils/logger');
+
+// ── TOOL REGISTRY ROUTES ──────────────────────────────────────────────────────
+const toolsRegistryRouter = express.Router();
+const registry = require('../../tools/registry');
+
+toolsRegistryRouter.get('/', (req, res) => {
+  res.json({ count: registry.count, tools: registry.list() });
+});
+
+toolsRegistryRouter.get('/groups', (req, res) => {
+  const groups = {};
+  for (const t of registry.list()) {
+    (groups[t.group] = groups[t.group] || []).push(t.name);
+  }
+  res.json(groups);
+});
+
+toolsRegistryRouter.post('/execute', async (req, res) => {
+  const { tool, input } = req.body;
+  if (!tool || !input) return res.status(400).json({ error: 'tool and input required' });
+  try {
+    const result = await registry.execute(tool, input);
+    res.json({ tool, result });
+  } catch (e) {
+    res.status(500).json({ error: e.message });
+  }
+});
+
+module.exports.toolsRegistryRouter = toolsRegistryRouter;
+
+// ── PROMPT ENGINEERING ROUTES ─────────────────────────────────────────────────
+const promptsRouter = express.Router();
+const pe = require('../../prompts/promptEngineer');
+
+promptsRouter.get('/templates', (req, res) => {
+  res.json({ templates: pe.listTemplates() });
+});
+promptsRouter.get('/templates/:name', (req, res) => {
+  const t = pe.getTemplate(req.params.name);
+  if (!t) return res.status(404).json({ error: 'Template not found' });
+  res.json(t);
+});
+promptsRouter.post('/templates', (req, res) => {
+  const { name, description, template, variables } = req.body;
+  if (!name || !template) return res.status(400).json({ error: 'name and template required' });
+  try { res.json(pe.saveTemplate(name, description, template, variables)); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+promptsRouter.delete('/templates/:name', (req, res) => {
+  try { res.json({ success: pe.deleteTemplate(req.params.name) }); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+promptsRouter.post('/apply', (req, res) => {
+  const { template, variables } = req.body;
+  if (!template) return res.status(400).json({ error: 'template required' });
+  try { res.json({ result: pe.applyTemplate(template, variables || {}) }); }
+  catch (e) { res.status(400).json({ error: e.message }); }
+});
+promptsRouter.post('/cot', (req, res) => {
+  const { prompt, style } = req.body;
+  if (!prompt) return res.status(400).json({ error: 'prompt required' });
+  res.json({ result: pe.injectCoT(prompt, style) });
+});
+promptsRouter.post('/analyse', async (req, res) => {
+  const { prompt } = req.body;
+  if (!prompt) return res.status(400).json({ error: 'prompt required' });
+  try { res.json(await pe.analyse(prompt, req.body)); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+promptsRouter.post('/improve', async (req, res) => {
+  const { prompt, goal, style } = req.body;
+  if (!prompt) return res.status(400).json({ error: 'prompt required' });
+  try { res.json(await pe.improve(prompt, { goal, style, sessionId: req.body.sessionId })); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+promptsRouter.post('/generate', async (req, res) => {
+  const { task, type, model, includeExamples } = req.body;
+  if (!task) return res.status(400).json({ error: 'task required' });
+  try { res.json(await pe.generate(task, { type, model, includeExamples, sessionId: req.body.sessionId })); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+promptsRouter.post('/ab-test', async (req, res) => {
+  const { promptA, promptB, testInput } = req.body;
+  if (!promptA || !promptB || !testInput) return res.status(400).json({ error: 'promptA, promptB, testInput required' });
+  try { res.json(await pe.abTest(promptA, promptB, testInput, req.body)); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+
+module.exports.promptsRouter = promptsRouter;
+
+// ── COMPACTOR ROUTES ──────────────────────────────────────────────────────────
+const compactorRouter = express.Router();
+const compactor = require('../../context/compactor');
+
+compactorRouter.post('/compact', async (req, res) => {
+  const { messages, sessionId, force } = req.body;
+  if (!messages?.length) return res.status(400).json({ error: 'messages array required' });
+  try { res.json(await compactor.compact(messages, { sessionId, force })); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+compactorRouter.post('/deep-compact', async (req, res) => {
+  const { messages, sessionId } = req.body;
+  if (!messages?.length) return res.status(400).json({ error: 'messages array required' });
+  try { res.json(await compactor.deepCompact(messages, { sessionId })); }
+  catch (e) { res.status(500).json({ error: e.message }); }
+});
+compactorRouter.post('/check', (req, res) => {
+  const { messages } = req.body;
+  res.json(compactor.needsCompaction(messages || []));
+});
+
+module.exports.compactorRouter = compactorRouter;