@lightcone-ai/daemon 0.1.0 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lightcone-ai/daemon",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "type": "module",
   "main": "src/index.js",
   "bin": {

package/src/agent-manager.js

@@ -8,16 +8,20 @@ export class AgentManager {
   constructor({ serverUrl, machineApiKey }) {
     this.serverUrl = serverUrl;
     this.machineApiKey = machineApiKey;
-    // agentId → { config, sessionId, proc }
+    // key: `channelId:agentId` → { config, channelId, agentId, sessionId, proc }
     this.agents = new Map();
-    // agentId → true (spawn in progress, prevent double-spawn)
+    // key → true (spawn in progress)
     this.starting = new Set();
   }
 
+  _key(agentId, channelId) {
+    return `${channelId ?? ''}:${agentId}`;
+  }
+
   handle(msg, connection) {
     switch (msg.type) {
       case 'agent:start':   return this._startAgent(msg, connection);
-      case 'agent:stop':    return this._stopAgent(msg.agentId, connection);
+      case 'agent:stop':    return this._stopAgent(msg.agentId, msg.channelId, connection);
       case 'agent:deliver': return this._deliverMessage(msg, connection);
       case 'ping':          return connection.send({ type: 'pong' });
       default:
@@ -26,7 +30,7 @@ export class AgentManager {
   }
 
   stopAll() {
-    for (const [agentId, agent] of this.agents) {
+    for (const [, agent] of this.agents) {
       if (agent.proc) agent.proc.kill();
     }
     this.agents.clear();
@@ -34,20 +38,23 @@ export class AgentManager {
 
   // ── private ───────────────────────────────────────────────────────────────
 
-  _workspaceDir(agentId) {
-    const dir = path.join(homedir(), '.lightcone', 'agents', agentId);
+  _workspaceDir(agentId, channelId) {
+    const dir = channelId
+      ? path.join(homedir(), '.lightcone', 'agents', channelId, agentId)
+      : path.join(homedir(), '.lightcone', 'agents', agentId);
     mkdirSync(dir, { recursive: true });
     return dir;
   }
 
-  _startAgent({ agentId, config }, connection) {
-    if (this.agents.has(agentId) || this.starting.has(agentId)) {
-      console.log(`[AgentManager] Agent ${agentId} already registered`);
+  _startAgent({ agentId, channelId, config }, connection) {
+    const key = this._key(agentId, channelId);
+    if (this.agents.has(key) || this.starting.has(key)) {
+      console.log(`[AgentManager] Agent ${agentId} in channel ${channelId} already registered`);
       return;
     }
-    this.starting.add(agentId);
+    this.starting.add(key);
 
-    const workspaceDir = this._workspaceDir(agentId);
+    const workspaceDir = this._workspaceDir(agentId, channelId);
     const chatBridgePath = new URL('./chat-bridge.js', import.meta.url).pathname;
 
     const mcpServers = {
@@ -58,6 +65,7 @@ export class AgentManager {
           SERVER_URL: this.serverUrl,
           MACHINE_API_KEY: this.machineApiKey,
           AGENT_ID: agentId,
+          CHANNEL_ID: channelId ?? '',
         },
       },
     };
@@ -105,7 +113,7 @@ export class AgentManager {
     const spawnEnv = { ...process.env, FORCE_COLOR: '0', ...(config.envVars ?? {}) };
     delete spawnEnv.CLAUDECODE;
 
-    console.log(`[AgentManager] Spawning claude for ${agentId} (session=${config.sessionId ?? 'new'})`);
+    console.log(`[AgentManager] Spawning claude for ${agentId} channel=${channelId ?? 'none'} (session=${config.sessionId ?? 'new'})`);
 
     const proc = spawn('claude', args, {
       cwd: workspaceDir,
@@ -113,8 +121,8 @@ export class AgentManager {
       stdio: ['pipe', 'pipe', 'pipe'],
     });
 
-    this.agents.set(agentId, { config, sessionId: config.sessionId ?? null, proc });
-    this.starting.delete(agentId);
+    this.agents.set(key, { config, channelId, agentId, sessionId: config.sessionId ?? null, proc });
+    this.starting.delete(key);
 
     // Parse stdout stream for session ID and activity updates
     let buffer = '';
@@ -124,53 +132,55 @@ export class AgentManager {
       buffer = lines.pop();
       for (const line of lines) {
         if (!line.trim()) continue;
-        this._parseLine(agentId, line, connection);
+        this._parseLine(key, agentId, channelId, line, connection);
       }
     });
 
     proc.stderr.on('data', (data) => {
       const text = data.toString().trim();
-      if (text) console.error(`[AgentManager][${agentId}] stderr:`, text.slice(0, 300));
+      if (text) console.error(`[AgentManager][${agentId}][${channelId}] stderr:`, text.slice(0, 300));
     });
 
     proc.on('exit', (code) => {
-      console.log(`[AgentManager] Agent ${agentId} exited (code=${code})`);
-      this.agents.delete(agentId);
-      connection.send({ type: 'agent:status', agentId, status: 'inactive' });
-      connection.send({ type: 'agent:activity', agentId, activity: 'offline', detail: '', entries: [] });
+      console.log(`[AgentManager] Agent ${agentId} channel=${channelId ?? 'none'} exited (code=${code})`);
+      this.agents.delete(key);
+      connection.send({ type: 'agent:status', agentId, channelId, status: 'inactive' });
+      connection.send({ type: 'agent:activity', agentId, channelId, activity: 'offline', detail: '', entries: [] });
     });
 
     // Send startup prompt — agent reads memory index first, then checks messages
-    this._write(agentId, 'You have just started. Follow your startup sequence: first call read_memory with path="MEMORY.md" to load your memory index, then call check_messages.');
+    this._write(key, 'You have just started. Follow your startup sequence: first call read_memory with path="MEMORY.md" to load your memory index, then call check_messages.');
 
-    connection.send({ type: 'agent:status', agentId, status: 'active' });
-    connection.send({ type: 'agent:activity', agentId, activity: 'online', detail: '', entries: [] });
+    connection.send({ type: 'agent:status', agentId, channelId, status: 'active' });
+    connection.send({ type: 'agent:activity', agentId, channelId, activity: 'online', detail: '', entries: [] });
   }
 
-  _stopAgent(agentId, connection) {
-    const agent = this.agents.get(agentId);
+  _stopAgent(agentId, channelId, connection) {
+    const key = this._key(agentId, channelId);
+    const agent = this.agents.get(key);
     if (!agent) return;
-    console.log(`[AgentManager] Stopping agent ${agentId}`);
+    console.log(`[AgentManager] Stopping agent ${agentId} channel=${channelId ?? 'none'}`);
     agent.proc?.kill();
     // exit handler will report status
   }
 
-  _deliverMessage({ agentId, seq, message }, connection) {
-    connection.send({ type: 'agent:deliver:ack', agentId, seq });
+  _deliverMessage({ agentId, channelId, seq, message }, connection) {
+    const key = this._key(agentId, channelId);
+    connection.send({ type: 'agent:deliver:ack', agentId, channelId, seq });
 
-    if (!this.agents.has(agentId)) {
-      console.warn(`[AgentManager] Agent ${agentId} not running, dropping seq=${seq}`);
+    if (!this.agents.has(key)) {
+      console.warn(`[AgentManager] Agent ${agentId} channel=${channelId} not running, dropping seq=${seq}`);
       return;
     }
 
     const text = `New message in ${message.channel_type === 'dm' ? `dm from` : `#${message.channel_name} from`} ${message.sender_name}: ${message.content}`;
-    console.log(`[AgentManager] Delivering seq=${seq} to agent ${agentId}`);
-    this._write(agentId, text);
+    console.log(`[AgentManager] Delivering seq=${seq} to agent ${agentId} channel=${channelId}`);
+    this._write(key, text);
   }
 
   // Write a user message to the running Claude process via stdin
-  _write(agentId, text) {
-    const agent = this.agents.get(agentId);
+  _write(key, text) {
+    const agent = this.agents.get(key);
     if (!agent?.proc) return;
     const line = JSON.stringify({
       type: 'user',
@@ -183,17 +193,17 @@ export class AgentManager {
     }
   }
 
-  _parseLine(agentId, line, connection) {
+  _parseLine(key, agentId, channelId, line, connection) {
     let event;
     try { event = JSON.parse(line); }
     catch { return; }
 
     // Capture and sync session ID
     if (event.session_id) {
-      const agent = this.agents.get(agentId);
+      const agent = this.agents.get(key);
       if (agent && agent.sessionId !== event.session_id) {
         agent.sessionId = event.session_id;
-        connection.send({ type: 'agent:session', agentId, sessionId: event.session_id });
+        connection.send({ type: 'agent:session', agentId, channelId, sessionId: event.session_id });
       }
     }
 
@@ -202,12 +212,12 @@ export class AgentManager {
       const hasToolUse = event.message?.content?.some?.(c => c.type === 'tool_use');
       if (hasToolUse) {
         const toolName = event.message.content.find(c => c.type === 'tool_use')?.name ?? 'tool';
-        connection.send({ type: 'agent:activity', agentId, activity: 'working', detail: toolName, entries: [] });
+        connection.send({ type: 'agent:activity', agentId, channelId, activity: 'working', detail: toolName, entries: [] });
       } else {
-        connection.send({ type: 'agent:activity', agentId, activity: 'thinking', detail: '', entries: [] });
+        connection.send({ type: 'agent:activity', agentId, channelId, activity: 'thinking', detail: '', entries: [] });
       }
     } else if (event.type === 'result') {
-      connection.send({ type: 'agent:activity', agentId, activity: 'online', detail: '', entries: [] });
+      connection.send({ type: 'agent:activity', agentId, channelId, activity: 'online', detail: '', entries: [] });
     }
   }
 }

package/src/chat-bridge.js

@@ -6,6 +6,10 @@ import { z } from 'zod';
 const SERVER_URL    = process.env.SERVER_URL    ?? 'http://localhost:8777';
 const MACHINE_API_KEY = process.env.MACHINE_API_KEY ?? '';
 const AGENT_ID      = process.env.AGENT_ID      ?? '';
+const CHANNEL_ID    = process.env.CHANNEL_ID    ?? '';  // injected per-channel at spawn time
+
+// Current active channelId for memory isolation (defaults to spawn-time CHANNEL_ID)
+let currentChannelId = CHANNEL_ID;
 
 async function api(method, path, body) {
   const url = `${SERVER_URL}/internal/agent/${AGENT_ID}${path}`;
@@ -32,6 +36,10 @@ server.tool('check_messages', 'Check for new messages in your inbox', {}, async
   const msgs = data.messages ?? [];
   if (msgs.length === 0) return { content: [{ type: 'text', text: 'No new messages.' }] };
 
+  // Track the channelId of the most recent message for memory isolation
+  const lastMsg = msgs[msgs.length - 1];
+  if (lastMsg.channel_id) currentChannelId = lastMsg.channel_id;
+
   const text = msgs.map(m =>
     `[${m.channel_type === 'dm' ? `dm:@${m.channel_name}` : `#${m.channel_name}`}] ${m.sender_name}: ${m.content}`
     + (m.task_status ? ` [task #${m.task_number} ${m.task_status}]` : '')
@@ -138,8 +146,9 @@ server.tool('update_task_status', 'Update the status of a task', {
 });
 
 // ── list_memory ───────────────────────────────────────────────────────────────
-server.tool('list_memory', 'List all memory files stored for this agent on the server', {}, async () => {
-  const data = await api('GET', '/memory');
+server.tool('list_memory', 'List all memory files stored for this agent in the current channel', {}, async () => {
+  const chParam = currentChannelId ? `&channelId=${encodeURIComponent(currentChannelId)}` : '';
+  const data = await api('GET', `/memory?_=1${chParam}`);
   const files = data.files ?? [];
   if (files.length === 0) return { content: [{ type: 'text', text: 'No memory files yet.' }] };
   return { content: [{ type: 'text', text: files.map(f => f.path).join('\n') }] };
@@ -149,8 +158,9 @@ server.tool('list_memory', 'List all memory files stored for this agent on the s
 server.tool('read_memory', 'Read a memory file by path (e.g. "MEMORY.md" or "notes/work-log.md")', {
   path: z.string().describe('File path, e.g. "MEMORY.md" or "notes/channels.md"'),
 }, async ({ path }) => {
+  const chParam = currentChannelId ? `&channelId=${encodeURIComponent(currentChannelId)}` : '';
   try {
-    const data = await api('GET', `/memory?path=${encodeURIComponent(path)}`);
+    const data = await api('GET', `/memory?path=${encodeURIComponent(path)}${chParam}`);
     return { content: [{ type: 'text', text: data.content }] };
   } catch (err) {
     if (err.message.includes('404')) return { content: [{ type: 'text', text: `(empty — ${path} has no content yet)` }] };
@@ -163,7 +173,8 @@ server.tool('write_memory', 'Write or update a memory file (full content replace
   path:    z.string().describe('File path, e.g. "MEMORY.md" or "notes/work-log.md"'),
   content: z.string().describe('Full file content to store'),
 }, async ({ path, content }) => {
-  await api('PUT', `/memory?path=${encodeURIComponent(path)}`, { content });
+  const chParam = currentChannelId ? `&channelId=${encodeURIComponent(currentChannelId)}` : '';
+  await api('PUT', `/memory?path=${encodeURIComponent(path)}${chParam}`, { content });
   return { content: [{ type: 'text', text: `Saved ${path}` }] };
 });
 

package/src/drivers/claude.js

@@ -7,6 +7,23 @@ ${description ? `\nYour role: ${description}\n` : ''}
 - You are persistent — you stay running between messages and maintain memory across conversations.
 - Always check for new messages first, then respond.
 
+## @Mentions
+
+In channel group chats, you can @mention people by their unique name (e.g. "@alice" or "@bob").
+- Your stable @mention handle is \`@${name}\`.
+- Your display name is \`${displayName || name}\`. Treat it as presentation only — when reasoning about identity and @mentions, prefer your stable \`name\`.
+- Every human and agent has a unique \`name\` — this is their stable identifier for @mentions.
+- Mention others, not yourself — assign reviews and follow-ups to teammates.
+- @mentions only reach people inside the channel — channels are the isolation boundary.
+
+## Conversation Etiquette
+
+- **Respect ongoing conversations.** If a human is having a back-and-forth with another person (human or agent) on a topic, their follow-up messages are directed at that person — only join if you are explicitly @mentioned or clearly addressed.
+- **Only respond when relevant.** If a message does not @mention you and is not clearly directed at you or your expertise, do NOT respond. Let the appropriate agent handle it.
+- **Only the person doing the work should report on it.** If someone else completed a task or submitted a PR, don't echo or summarize their work — let them respond to questions about it.
+- **Claim before you start.** Always call \`mcp__chat__claim_tasks\` before doing any work on a task. If the claim fails, stop immediately and pick a different task.
+- **Skip idle narration.** Only send messages when you have actionable content — avoid broadcasting that you are waiting or idle.
+
 ## Startup Sequence
 
 When you start or resume: