let-them-talk 3.3.3 → 3.4.1

package/dashboard.js

@@ -5,6 +5,15 @@ const path = require('path');
 const os = require('os');
 const { spawn } = require('child_process');
 
+// --- File-level mutex for serializing read-then-write operations ---
+const lockMap = new Map();
+function withFileLock(filePath, fn) {
+  const prev = lockMap.get(filePath) || Promise.resolve();
+  const next = prev.then(fn, fn);
+  lockMap.set(filePath, next.then(() => {}, () => {}));
+  return next;
+}
+
 const PORT = parseInt(process.env.AGENT_BRIDGE_PORT || '3000', 10);
 const LAN_STATE_FILE = path.join(__dirname, '.lan-mode');
 let LAN_MODE = process.env.AGENT_BRIDGE_LAN === 'true' || (fs.existsSync(LAN_STATE_FILE) && fs.readFileSync(LAN_STATE_FILE, 'utf8').trim() === 'true');
@@ -228,10 +237,78 @@ function apiStatus(query) {
   };
 }
 
+function apiStats(query) {
+  const projectPath = query.get('project') || null;
+  const history = readJsonl(filePath('history.jsonl', projectPath));
+  const agents = readJson(filePath('agents.json', projectPath));
+
+  // Per-agent stats
+  const perAgent = {};
+  let totalMessages = history.length;
+  const hourBuckets = new Array(24).fill(0);
+
+  for (let i = 0; i < history.length; i++) {
+    const m = history[i];
+    const from = m.from || 'unknown';
+    if (!perAgent[from]) {
+      perAgent[from] = { messages: 0, responseTimes: [], hours: new Array(24).fill(0) };
+    }
+    perAgent[from].messages++;
+    const ts = new Date(m.timestamp);
+    const hour = ts.getHours();
+    perAgent[from].hours[hour]++;
+    hourBuckets[hour]++;
+
+    // Compute response time if this is a reply
+    if (m.reply_to) {
+      for (let j = i - 1; j >= Math.max(0, i - 50); j--) {
+        if (history[j].id === m.reply_to) {
+          const delta = ts.getTime() - new Date(history[j].timestamp).getTime();
+          if (delta > 0 && delta < 3600000) perAgent[from].responseTimes.push(delta);
+          break;
+        }
+      }
+    }
+  }
+
+  // Build per-agent summary
+  const agentStats = {};
+  let busiestAgent = null;
+  let busiestCount = 0;
+  for (const [name, data] of Object.entries(perAgent)) {
+    const avgResponseMs = data.responseTimes.length
+      ? Math.round(data.responseTimes.reduce((a, b) => a + b, 0) / data.responseTimes.length)
+      : null;
+    const peakHour = data.hours.indexOf(Math.max(...data.hours));
+    agentStats[name] = {
+      messages: data.messages,
+      avg_response_ms: avgResponseMs,
+      peak_hour: peakHour,
+    };
+    if (data.messages > busiestCount) {
+      busiestCount = data.messages;
+      busiestAgent = name;
+    }
+  }
+
+  // Conversation velocity (messages per minute over last 10 minutes)
+  const tenMinAgo = Date.now() - 600000;
+  const recentCount = history.filter(m => new Date(m.timestamp).getTime() > tenMinAgo).length;
+  const velocity = Math.round((recentCount / 10) * 10) / 10;
+
+  return {
+    total_messages: totalMessages,
+    busiest_agent: busiestAgent,
+    velocity_per_min: velocity,
+    hour_distribution: hourBuckets,
+    agents: agentStats,
+  };
+}
+
 function apiReset(query) {
   const projectPath = query.get('project') || null;
   const dataDir = resolveDataDir(projectPath);
-  const fixedFiles = ['messages.jsonl', 'history.jsonl', 'agents.json', 'acks.json', 'tasks.json', 'profiles.json', 'workflows.json', 'branches.json', 'plugins.json'];
+  const fixedFiles = ['messages.jsonl', 'history.jsonl', 'agents.json', 'acks.json', 'tasks.json', 'profiles.json', 'workflows.json', 'branches.json', 'plugins.json', 'read_receipts.json', 'permissions.json'];
   for (const f of fixedFiles) {
     const p = path.join(dataDir, f);
     if (fs.existsSync(p)) fs.unlinkSync(p);
@@ -528,9 +605,12 @@ function apiUpdateTask(body, query) {
   const task = tasks.find(t => t.id === body.task_id);
   if (!task) return { error: 'Task not found' };
 
+  const validStatuses = ['pending', 'in_progress', 'done', 'blocked'];
+  if (!validStatuses.includes(body.status)) return { error: 'Invalid status. Must be: ' + validStatuses.join(', ') };
   task.status = body.status;
   task.updated_at = new Date().toISOString();
   if (body.notes) {
+    if (!Array.isArray(task.notes)) task.notes = [];
     task.notes.push({ by: 'Dashboard', text: body.notes, at: new Date().toISOString() });
   }
 
@@ -662,6 +742,244 @@ function apiLaunchAgent(body) {
   };
 }
 
+// --- v3.4: Message Edit ---
+async function apiEditMessage(body, query) {
+  const projectPath = query.get('project') || null;
+  const { id, content } = body;
+  if (!id || !content) return { error: 'Missing "id" and/or "content" fields' };
+  if (content.length > 50000) return { error: 'Content too long (max 50000 chars)' };
+
+  const dataDir = resolveDataDir(projectPath);
+  const historyFile = path.join(dataDir, 'history.jsonl');
+  const messagesFile = path.join(dataDir, 'messages.jsonl');
+
+  let found = false;
+  const now = new Date().toISOString();
+
+  // Update in history.jsonl (locked)
+  await withFileLock(historyFile, () => {
+    if (fs.existsSync(historyFile)) {
+      const lines = fs.readFileSync(historyFile, 'utf8').trim().split('\n').filter(Boolean);
+      const updated = lines.map(line => {
+        try {
+          const msg = JSON.parse(line);
+          if (msg.id === id) {
+            found = true;
+            if (!msg.edit_history) msg.edit_history = [];
+            msg.edit_history.push({ content: msg.content, edited_at: now });
+            msg.content = content;
+            msg.edited = true;
+            msg.edited_at = now;
+            return JSON.stringify(msg);
+          }
+          return line;
+        } catch { return line; }
+      });
+      if (found) fs.writeFileSync(historyFile, updated.join('\n') + '\n');
+    }
+  });
+
+  // Also update in messages.jsonl (locked independently)
+  if (found) {
+    await withFileLock(messagesFile, () => {
+      if (fs.existsSync(messagesFile)) {
+        const raw = fs.readFileSync(messagesFile, 'utf8').trim();
+        if (raw) {
+          const lines = raw.split('\n');
+          const updated = lines.map(line => {
+            try {
+              const msg = JSON.parse(line);
+              if (msg.id === id) {
+                msg.content = content;
+                msg.edited = true;
+                msg.edited_at = now;
+                return JSON.stringify(msg);
+              }
+              return line;
+            } catch { return line; }
+          });
+          fs.writeFileSync(messagesFile, updated.join('\n') + '\n');
+        }
+      }
+    });
+  }
+
+  if (!found) return { error: 'Message not found' };
+  return { success: true, id, edited_at: now };
+}
+
+// --- v3.4: Message Delete ---
+async function apiDeleteMessage(body, query) {
+  const projectPath = query.get('project') || null;
+  const { id } = body;
+  if (!id) return { error: 'Missing "id" field' };
+
+  const dataDir = resolveDataDir(projectPath);
+  const historyFile = path.join(dataDir, 'history.jsonl');
+  const messagesFile = path.join(dataDir, 'messages.jsonl');
+
+  let found = false;
+  let msgFrom = null;
+
+  // Find the message and remove from history.jsonl (locked)
+  await withFileLock(historyFile, () => {
+    if (fs.existsSync(historyFile)) {
+      const lines = fs.readFileSync(historyFile, 'utf8').trim().split('\n');
+      for (const line of lines) {
+        try {
+          const msg = JSON.parse(line);
+          if (msg.id === id) { found = true; msgFrom = msg.from; break; }
+        } catch {}
+      }
+
+      if (found) {
+        const allowed = ['Dashboard', 'dashboard', 'system', '__system__'];
+        if (allowed.includes(msgFrom)) {
+          const filtered = lines.filter(line => {
+            try { return JSON.parse(line).id !== id; } catch { return true; }
+          });
+          fs.writeFileSync(historyFile, filtered.join('\n') + (filtered.length ? '\n' : ''));
+        }
+      }
+    }
+  });
+
+  if (!found) return { error: 'Message not found' };
+
+  // Only allow deleting dashboard-injected or system messages
+  const allowed = ['Dashboard', 'dashboard', 'system', '__system__'];
+  if (!allowed.includes(msgFrom)) {
+    return { error: 'Can only delete messages sent from Dashboard or system' };
+  }
+
+  // Remove from messages.jsonl (locked independently)
+  await withFileLock(messagesFile, () => {
+    if (fs.existsSync(messagesFile)) {
+      const lines = fs.readFileSync(messagesFile, 'utf8').trim().split('\n');
+      const filtered = lines.filter(line => {
+        try { return JSON.parse(line).id !== id; } catch { return true; }
+      });
+      fs.writeFileSync(messagesFile, filtered.join('\n') + (filtered.length ? '\n' : ''));
+    }
+  });
+
+  return { success: true, id };
+}
+
+// --- v3.4: Conversation Templates ---
+function apiGetConversationTemplates() {
+  const templatesDir = path.join(__dirname, 'conversation-templates');
+  if (!fs.existsSync(templatesDir)) {
+    // Return built-in templates
+    return getBuiltInConversationTemplates();
+  }
+  const custom = fs.readdirSync(templatesDir)
+    .filter(f => f.endsWith('.json'))
+    .map(f => { try { return JSON.parse(fs.readFileSync(path.join(templatesDir, f), 'utf8')); } catch { return null; } })
+    .filter(Boolean);
+  return [...getBuiltInConversationTemplates(), ...custom];
+}
+
+function getBuiltInConversationTemplates() {
+  return [
+    {
+      id: 'code-review',
+      name: 'Code Review Pipeline',
+      description: 'Developer writes code, Reviewer checks it, Tester validates',
+      agents: [
+        { name: 'Developer', role: 'Developer', prompt: 'You are a developer. Write code as instructed. After completing, send your code to Reviewer for review.' },
+        { name: 'Reviewer', role: 'Code Reviewer', prompt: 'You are a code reviewer. Wait for code from Developer. Review it for bugs, style, and best practices. Send feedback back to Developer or approve and forward to Tester.' },
+        { name: 'Tester', role: 'QA Tester', prompt: 'You are a QA tester. Wait for approved code from Reviewer. Write and run tests. Report results back to the team.' }
+      ],
+      workflow: { name: 'Code Review', steps: ['Write Code', 'Review', 'Test', 'Approve'] }
+    },
+    {
+      id: 'debug-squad',
+      name: 'Debug Squad',
+      description: 'Investigator finds the bug, Fixer patches it, Verifier confirms the fix',
+      agents: [
+        { name: 'Investigator', role: 'Bug Investigator', prompt: 'You investigate bugs. Analyze error logs, trace code paths, and identify root causes. Send findings to Fixer.' },
+        { name: 'Fixer', role: 'Bug Fixer', prompt: 'You fix bugs. Wait for findings from Investigator. Implement fixes and send to Verifier for confirmation.' },
+        { name: 'Verifier', role: 'Fix Verifier', prompt: 'You verify bug fixes. Wait for patches from Fixer. Test the fix and confirm resolution or send back for more work.' }
+      ],
+      workflow: { name: 'Bug Fix', steps: ['Investigate', 'Fix', 'Verify', 'Close'] }
+    },
+    {
+      id: 'feature-build',
+      name: 'Feature Development',
+      description: 'Architect designs, Builder implements, Reviewer approves',
+      agents: [
+        { name: 'Architect', role: 'Software Architect', prompt: 'You are a software architect. Design the feature architecture, define interfaces, and create the implementation plan. Send the plan to Builder.' },
+        { name: 'Builder', role: 'Developer', prompt: 'You are a developer. Wait for architecture plans from Architect. Implement the feature following the design. Send completed code to Reviewer.' },
+        { name: 'Reviewer', role: 'Senior Reviewer', prompt: 'You are a senior reviewer. Review implementations from Builder against the architecture from Architect. Approve or request changes.' }
+      ],
+      workflow: { name: 'Feature Dev', steps: ['Design', 'Implement', 'Review', 'Ship'] }
+    },
+    {
+      id: 'research-write',
+      name: 'Research & Write',
+      description: 'Researcher gathers info, Writer creates content, Editor polishes',
+      agents: [
+        { name: 'Researcher', role: 'Researcher', prompt: 'You are a researcher. Gather information on the given topic. Organize findings and send a research brief to Writer.' },
+        { name: 'Writer', role: 'Writer', prompt: 'You are a writer. Wait for research from Researcher. Write clear, well-structured content based on the findings. Send to Editor.' },
+        { name: 'Editor', role: 'Editor', prompt: 'You are an editor. Review and polish content from Writer. Check for clarity, accuracy, and style. Send back final version or request revisions.' }
+      ],
+      workflow: { name: 'Content Pipeline', steps: ['Research', 'Draft', 'Edit', 'Publish'] }
+    }
+  ];
+}
+
+function apiLaunchConversationTemplate(body, query) {
+  const projectPath = query.get('project') || null;
+  const { template_id } = body;
+  if (!template_id) return { error: 'Missing template_id' };
+
+  const templates = apiGetConversationTemplates();
+  const template = templates.find(t => t.id === template_id);
+  if (!template) return { error: 'Template not found: ' + template_id };
+
+  // Return the template config for the frontend to display launch instructions
+  return {
+    success: true,
+    template,
+    instructions: template.agents.map(a => ({
+      agent_name: a.name,
+      role: a.role,
+      prompt: `You are "${a.name}" with role "${a.role}". ${a.prompt}\n\nFirst register yourself with: register(name="${a.name}"), then update_profile(role="${a.role}"). Then enter listen mode.`
+    }))
+  };
+}
+
+// --- v3.4: Agent Permissions ---
+function apiUpdatePermissions(body, query) {
+  const projectPath = query.get('project') || null;
+  const dataDir = resolveDataDir(projectPath);
+  const permFile = path.join(dataDir, 'permissions.json');
+
+  const { agent, permissions } = body;
+  if (!agent || !permissions) return { error: 'Missing "agent" and/or "permissions" fields' };
+
+  let perms = {};
+  if (fs.existsSync(permFile)) {
+    try { perms = JSON.parse(fs.readFileSync(permFile, 'utf8')); } catch {}
+  }
+
+  // permissions: { can_read: [agents...] or "*", can_write_to: [agents...] or "*", is_admin: bool }
+  const allowed = {};
+  if (permissions.can_read !== undefined) allowed.can_read = permissions.can_read;
+  if (permissions.can_write_to !== undefined) allowed.can_write_to = permissions.can_write_to;
+  if (permissions.is_admin !== undefined) allowed.is_admin = !!permissions.is_admin;
+  perms[agent] = {
+    ...perms[agent],
+    ...allowed,
+    updated_at: new Date().toISOString()
+  };
+
+  if (!fs.existsSync(dataDir)) fs.mkdirSync(dataDir, { recursive: true });
+  fs.writeFileSync(permFile, JSON.stringify(perms, null, 2));
+  return { success: true, agent, permissions: perms[agent] };
+}
+
 // --- HTTP Server ---
 
 // Load HTML at startup (re-read on each request in dev for hot-reload)
@@ -696,7 +1014,7 @@ const server = http.createServer(async (req, res) => {
   } else if (reqOrigin === allowedOrigin || reqOrigin === `http://127.0.0.1:${PORT}`) {
     res.setHeader('Access-Control-Allow-Origin', reqOrigin);
   }
-  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
+  res.setHeader('Access-Control-Allow-Methods', 'GET, POST, PUT, DELETE, OPTIONS');
   res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
 
   if (req.method === 'OPTIONS') {
@@ -706,7 +1024,7 @@ const server = http.createServer(async (req, res) => {
   }
 
   // CSRF + DNS rebinding protection: validate Host and Origin on mutating requests
-  if (req.method === 'POST' || req.method === 'DELETE') {
+  if (req.method === 'POST' || req.method === 'PUT' || req.method === 'DELETE') {
     // Check Host header to block DNS rebinding attacks
     const host = (req.headers.host || '').replace(/:\d+$/, '');
     const validHosts = ['localhost', '127.0.0.1'];
@@ -775,6 +1093,10 @@ const server = http.createServer(async (req, res) => {
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify(apiStatus(url.searchParams)));
     }
+    else if (url.pathname === '/api/stats' && req.method === 'GET') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(apiStats(url.searchParams)));
+    }
     else if (url.pathname === '/api/reset' && req.method === 'POST') {
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify(apiReset(url.searchParams)));
@@ -819,7 +1141,7 @@ const server = http.createServer(async (req, res) => {
       });
       res.end(html);
     }
-    else if (url.pathname === '/api/discover' && req.method === 'GET') {
+    else if (url.pathname === '/api/discover' && req.method === 'POST') {
       res.writeHead(200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify(apiDiscover()));
     }
@@ -851,7 +1173,7 @@ const server = http.createServer(async (req, res) => {
     else if (url.pathname === '/api/workspaces' && req.method === 'GET') {
       const projectPath = url.searchParams.get('project') || null;
       const agentParam = url.searchParams.get('agent');
-      if (agentParam && !/^[a-zA-Z0-9]{1,20}$/.test(agentParam)) {
+      if (agentParam && !/^[a-zA-Z0-9_-]{1,20}$/.test(agentParam)) {
         res.writeHead(400, { 'Content-Type': 'application/json' });
         res.end(JSON.stringify({ error: 'Invalid agent name' }));
         return;
@@ -953,6 +1275,49 @@ const server = http.createServer(async (req, res) => {
       res.writeHead(result.error ? 400 : 200, { 'Content-Type': 'application/json' });
       res.end(JSON.stringify(result));
     }
+    // --- v3.4: Message Edit ---
+    else if (url.pathname === '/api/message' && req.method === 'PUT') {
+      const body = await parseBody(req);
+      const result = await apiEditMessage(body, url.searchParams);
+      res.writeHead(result.error ? 400 : 200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(result));
+    }
+    // --- v3.4: Message Delete ---
+    else if (url.pathname === '/api/message' && req.method === 'DELETE') {
+      const body = await parseBody(req);
+      const result = await apiDeleteMessage(body, url.searchParams);
+      res.writeHead(result.error ? 400 : 200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(result));
+    }
+    // --- v3.4: Conversation Templates ---
+    else if (url.pathname === '/api/conversation-templates' && req.method === 'GET') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(apiGetConversationTemplates()));
+    }
+    else if (url.pathname === '/api/conversation-templates/launch' && req.method === 'POST') {
+      const body = await parseBody(req);
+      const result = apiLaunchConversationTemplate(body, url.searchParams);
+      res.writeHead(result.error ? 400 : 200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(result));
+    }
+    // --- v3.4: Agent Permissions ---
+    else if (url.pathname === '/api/permissions' && req.method === 'GET') {
+      const projectPath = url.searchParams.get('project') || null;
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(readJson(filePath('permissions.json', projectPath))));
+    }
+    else if (url.pathname === '/api/permissions' && req.method === 'POST') {
+      const body = await parseBody(req);
+      const result = apiUpdatePermissions(body, url.searchParams);
+      res.writeHead(result.error ? 400 : 200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(result));
+    }
+    // --- v3.4: Read Receipts ---
+    else if (url.pathname === '/api/read-receipts' && req.method === 'GET') {
+      const projectPath = url.searchParams.get('project') || null;
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify(readJson(filePath('read_receipts.json', projectPath))));
+    }
     // Server info (LAN mode detection for frontend)
     else if (url.pathname === '/api/server-info' && req.method === 'GET') {
       res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -1028,8 +1393,9 @@ const server = http.createServer(async (req, res) => {
       res.end(JSON.stringify({ error: 'Not found' }));
     }
   } catch (err) {
+    console.error('Server error:', err.message);
     res.writeHead(500, { 'Content-Type': 'application/json' });
-    res.end(JSON.stringify({ error: err.message }));
+    res.end(JSON.stringify({ error: 'Internal server error' }));
   }
 });
 
@@ -1081,7 +1447,7 @@ server.listen(PORT, LAN_MODE ? '0.0.0.0' : '127.0.0.1', () => {
   const dataDir = resolveDataDir();
   const lanIP = getLanIP();
   console.log('');
-  console.log('  Let Them Talk - Agent Bridge Dashboard v3.3.3');
+  console.log('  Let Them Talk - Agent Bridge Dashboard v3.4.1');
   console.log('  ============================================');
   console.log('  Dashboard:  http://localhost:' + PORT);
   if (LAN_MODE && lanIP) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "let-them-talk",
-  "version": "3.3.3",
+  "version": "3.4.1",
   "description": "MCP message broker + web dashboard for inter-agent communication. Let AI CLI agents talk to each other.",
   "main": "server.js",
   "bin": {
@@ -21,6 +21,7 @@
     "dashboard.html",
     "cli.js",
     "templates/",
+    "conversation-templates/",
     "logo.png",
     "LICENSE",
     "SECURITY.md",

package/server.js

@@ -273,14 +273,61 @@ function autoCompact() {
   } catch {}
 }
 
+// --- Permissions helpers ---
+const PERMISSIONS_FILE = path.join(DATA_DIR, 'permissions.json');
+
+function getPermissions() {
+  if (!fs.existsSync(PERMISSIONS_FILE)) return {};
+  try { return JSON.parse(fs.readFileSync(PERMISSIONS_FILE, 'utf8')); } catch { return {}; }
+}
+
+function canSendTo(sender, recipient) {
+  const perms = getPermissions();
+  // If no permissions set, allow everything (backward compatible)
+  if (!perms[sender] && !perms[recipient]) return true;
+  // Check sender's write permissions
+  if (perms[sender] && perms[sender].can_write_to) {
+    const allowed = perms[sender].can_write_to;
+    if (allowed !== '*' && Array.isArray(allowed) && !allowed.includes(recipient)) return false;
+  }
+  // Check recipient's read permissions
+  if (perms[recipient] && perms[recipient].can_read) {
+    const allowed = perms[recipient].can_read;
+    if (allowed !== '*' && Array.isArray(allowed) && !allowed.includes(sender)) return false;
+  }
+  return true;
+}
+
+// --- Read receipts helpers ---
+const READ_RECEIPTS_FILE = path.join(DATA_DIR, 'read_receipts.json');
+
+function getReadReceipts() {
+  if (!fs.existsSync(READ_RECEIPTS_FILE)) return {};
+  try { return JSON.parse(fs.readFileSync(READ_RECEIPTS_FILE, 'utf8')); } catch { return {}; }
+}
+
+function markAsRead(agentName, messageId) {
+  ensureDataDir();
+  const receipts = getReadReceipts();
+  if (!receipts[messageId]) receipts[messageId] = {};
+  receipts[messageId][agentName] = new Date().toISOString();
+  fs.writeFileSync(READ_RECEIPTS_FILE, JSON.stringify(receipts, null, 2));
+}
+
 // Get unconsumed messages for an agent (full scan — used by check_messages and initial load)
 function getUnconsumedMessages(agentName, fromFilter = null) {
   const messages = readJsonl(getMessagesFile(currentBranch));
   const consumed = getConsumedIds(agentName);
+  const perms = getPermissions();
   return messages.filter(m => {
     if (m.to !== agentName) return false;
     if (consumed.has(m.id)) return false;
     if (fromFilter && m.from !== fromFilter && !m.system) return false;
+    // Permission check: skip messages from senders this agent can't read
+    if (perms[agentName] && perms[agentName].can_read) {
+      const allowed = perms[agentName].can_read;
+      if (allowed !== '*' && Array.isArray(allowed) && !allowed.includes(m.from) && !m.system) return false;
+    }
     return true;
   });
 }
@@ -520,6 +567,11 @@ function toolSendMessage(content, to = null, reply_to = null) {
     return { error: 'Cannot send a message to yourself' };
   }
 
+  // Permission check
+  if (!canSendTo(registeredName, to)) {
+    return { error: `Permission denied: you are not allowed to send messages to "${to}"` };
+  }
+
   const sizeErr = validateContentSize(content);
   if (sizeErr) return sizeErr;
 
@@ -583,7 +635,9 @@ function toolBroadcast(content) {
 
   ensureDataDir();
   const ids = [];
+  const skipped = [];
   for (const to of otherAgents) {
+    if (!canSendTo(registeredName, to)) { skipped.push(to); continue; }
     messageSeq++;
     const msg = {
       id: generateId(),
@@ -600,7 +654,9 @@ function toolBroadcast(content) {
   }
   touchActivity();
 
-  return { success: true, sent_to: ids, recipient_count: otherAgents.length };
+  const result = { success: true, sent_to: ids, recipient_count: ids.length };
+  if (skipped.length > 0) result.skipped = skipped;
+  return result;
 }
 
 async function toolWaitForReply(timeoutSeconds = 300, from = null) {
@@ -618,6 +674,7 @@ async function toolWaitForReply(timeoutSeconds = 300, from = null) {
     const consumed = getConsumedIds(registeredName);
     consumed.add(msg.id);
     saveConsumedIds(registeredName, consumed);
+    markAsRead(registeredName, msg.id);
     const _mf1 = getMessagesFile(currentBranch);
     if (fs.existsSync(_mf1)) {
       lastReadOffset = fs.statSync(_mf1).size;
@@ -647,6 +704,7 @@ async function toolWaitForReply(timeoutSeconds = 300, from = null) {
 
       consumed.add(msg.id);
       saveConsumedIds(registeredName, consumed);
+      markAsRead(registeredName, msg.id);
       touchActivity();
       setListening(false);
       return buildMessageResponse(msg, consumed);
@@ -718,6 +776,7 @@ async function toolListen(from = null) {
     const consumed = getConsumedIds(registeredName);
     consumed.add(msg.id);
     saveConsumedIds(registeredName, consumed);
+    markAsRead(registeredName, msg.id);
     const _mfL1 = getMessagesFile(currentBranch);
     if (fs.existsSync(_mfL1)) {
       lastReadOffset = fs.statSync(_mfL1).size;
@@ -750,6 +809,7 @@ async function toolListen(from = null) {
 
         consumed.add(msg.id);
         saveConsumedIds(registeredName, consumed);
+        markAsRead(registeredName, msg.id);
         touchActivity();
         setListening(false);
         return buildMessageResponse(msg, consumed);
@@ -776,6 +836,7 @@ async function toolListenCodex(from = null) {
     const consumed = getConsumedIds(registeredName);
     consumed.add(msg.id);
     saveConsumedIds(registeredName, consumed);
+    markAsRead(registeredName, msg.id);
     const _mfC1 = getMessagesFile(currentBranch);
     if (fs.existsSync(_mfC1)) {
       lastReadOffset = fs.statSync(_mfC1).size;
@@ -804,6 +865,7 @@ async function toolListenCodex(from = null) {
 
       consumed.add(msg.id);
       saveConsumedIds(registeredName, consumed);
+      markAsRead(registeredName, msg.id);
       touchActivity();
       setListening(false);
       return buildMessageResponse(msg, consumed);
@@ -824,6 +886,16 @@ function toolGetHistory(limit = 50, thread_id = null) {
   if (thread_id) {
     history = history.filter(m => m.thread_id === thread_id || m.id === thread_id);
   }
+  // Filter by permissions — only show messages involving this agent or permitted senders
+  if (registeredName) {
+    const perms = getPermissions();
+    if (perms[registeredName] && perms[registeredName].can_read) {
+      const allowed = perms[registeredName].can_read;
+      if (allowed !== '*' && Array.isArray(allowed)) {
+        history = history.filter(m => m.from === registeredName || m.to === registeredName || allowed.includes(m.from));
+      }
+    }
+  }
   const recent = history.slice(-limit);
   const acks = getAcks();
 
@@ -1109,8 +1181,8 @@ function toolReset() {
       }
     }
   }
-  // Remove profiles, workflows, branches, plugins
-  for (const f of [PROFILES_FILE, WORKFLOWS_FILE, BRANCHES_FILE, PLUGINS_FILE]) {
+  // Remove profiles, workflows, branches, plugins, permissions, read receipts
+  for (const f of [PROFILES_FILE, WORKFLOWS_FILE, BRANCHES_FILE, PLUGINS_FILE, PERMISSIONS_FILE, READ_RECEIPTS_FILE]) {
     if (fs.existsSync(f)) fs.unlinkSync(f);
   }
   // Remove workspaces dir
@@ -1186,6 +1258,9 @@ function toolWorkspaceWrite(key, content) {
 function toolWorkspaceRead(key, agent) {
   if (!registeredName) return { error: 'You must call register() first' };
   const targetAgent = agent || registeredName;
+  if (targetAgent !== registeredName && !/^[a-zA-Z0-9_-]{1,20}$/.test(targetAgent)) {
+    return { error: 'Invalid agent name' };
+  }
 
   const ws = getWorkspace(targetAgent);
   if (key) {
@@ -1203,6 +1278,7 @@ function toolWorkspaceRead(key, agent) {
 function toolWorkspaceList(agent) {
   const agents = getAgents();
   if (agent) {
+    if (!/^[a-zA-Z0-9_-]{1,20}$/.test(agent)) return { error: 'Invalid agent name' };
     const ws = getWorkspace(agent);
     return { agent, keys: Object.keys(ws).map(k => ({ key: k, size: ws[k].content.length, updated_at: ws[k].updated_at })) };
   }
@@ -2021,7 +2097,7 @@ async function main() {
   loadPlugins();
   const transport = new StdioServerTransport();
   await server.connect(transport);
-  console.error('Agent Bridge MCP server v3.3.3 running (' + (27 + loadedPlugins.length) + ' tools)');
+  console.error('Agent Bridge MCP server v3.4.1 running (' + (27 + loadedPlugins.length) + ' tools)');
 }
 
 main().catch(console.error);