@lightcone-ai/daemon 0.6.9 → 0.7.1

package/package.json

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

package/src/agent-manager.js

@@ -10,20 +10,20 @@ export class AgentManager {
   constructor({ serverUrl, machineApiKey }) {
     this.serverUrl = serverUrl;
     this.machineApiKey = machineApiKey;
-    // key: `channelId:agentId` → { config, channelId, agentId, sessionId, proc }
+    // key: `teamId:agentId` → { config, teamId, agentId, sessionId, proc }
     this.agents = new Map();
     // key → true (spawn in progress)
     this.starting = new Set();
   }
 
-  _key(agentId, channelId) {
-    return `${channelId ?? ''}:${agentId}`;
+  _key(agentId, teamId) {
+    return `${teamId ?? ''}:${agentId}`;
   }
 
   handle(msg, connection) {
     switch (msg.type) {
       case 'agent:start':       return this._startAgent(msg, connection);
-      case 'agent:stop':        return this._stopAgent(msg.agentId, msg.channelId, connection);
+      case 'agent:stop':        return this._stopAgent(msg.agentId, msg.teamId, connection);
       case 'agent:deliver':     return this._deliverMessage(msg, connection);
       case 'ping':              return connection.send({ type: 'pong' });
       default:
@@ -40,16 +40,16 @@ export class AgentManager {
 
   // ── private ───────────────────────────────────────────────────────────────
 
-  _workspaceDir(agentId, channelId) {
-    const dir = channelId
-      ? path.join(homedir(), '.lightcone', 'agents', channelId, agentId)
+  _workspaceDir(agentId, teamId) {
+    const dir = teamId
+      ? path.join(homedir(), '.lightcone', 'agents', teamId, agentId)
       : path.join(homedir(), '.lightcone', 'agents', agentId);
     mkdirSync(dir, { recursive: true });
     return dir;
   }
 
   _formatDeliveryText(message) {
-    return `New message in ${message.channel_type === 'dm' ? 'dm from' : `#${message.channel_name} from`} ${message.sender_name}: ${message.content}`;
+    return `New message in ${message.team_type === 'dm' ? 'dm from' : `#${message.team_name} from`} ${message.sender_name}: ${message.content}`;
   }
 
   _takePendingMessage(key) {
@@ -61,23 +61,23 @@ export class AgentManager {
     return msg;
   }
 
-  async _startAgent({ agentId, channelId, channelName, config }, connection) {
-    const key = this._key(agentId, channelId);
+  async _startAgent({ agentId, teamId, teamName, config }, connection) {
+    const key = this._key(agentId, teamId);
     if (this.agents.has(key) || this.starting.has(key)) {
-      console.log(`[AgentManager] Agent ${agentId} in channel ${channelId} already registered`);
+      console.log(`[AgentManager] Agent ${agentId} in team ${teamId} already registered`);
       return;
     }
     this.starting.add(key);
 
     const runtime = config.runtime ?? 'claude';
-    const workspaceDir = this._workspaceDir(agentId, channelId);
+    const workspaceDir = this._workspaceDir(agentId, teamId);
     const chatBridgePath = new URL('./chat-bridge.js', import.meta.url).pathname;
     const startupMsg = runtime === 'codex' ? this._takePendingMessage(key) : null;
 
     // Fetch skills index for system prompt + MCP derivation (non-blocking on failure)
     let skills = [];
     try {
-      const chParam = channelId ? `?channelId=${encodeURIComponent(channelId)}` : '';
+      const chParam = teamId ? `?teamId=${encodeURIComponent(teamId)}` : '';
       const res = await fetch(`${this.serverUrl}/internal/agent/${agentId}/skills${chParam}`, {
         headers: { 'Authorization': `Bearer ${this.machineApiKey}` },
       });
@@ -91,11 +91,11 @@ export class AgentManager {
     if (runtime === 'kimi') {
       // ── Kimi CLI ──────────────────────────────────────────────────────────
       const kimiSpawn = buildKimiSpawn({
-        config, agentId, channelId, workspaceDir, chatBridgePath,
+        config, agentId, teamId, workspaceDir, chatBridgePath,
         serverUrl: this.serverUrl, machineApiKey: this.machineApiKey, skills,
       });
 
-      console.log(`[AgentManager] Spawning kimi for ${config.displayName ?? agentId} channel=${channelName ?? channelId ?? 'none'} (session=${kimiSpawn.sessionId})`);
+      console.log(`[AgentManager] Spawning kimi for ${config.displayName ?? agentId} team=${teamName ?? teamId ?? 'none'} (session=${kimiSpawn.sessionId})`);
 
       proc = spawn('kimi', kimiSpawn.args, {
         cwd: workspaceDir,
@@ -113,7 +113,7 @@ export class AgentManager {
       const kimiState = { sessionId: kimiSpawn.sessionId, sessionAnnounced: false };
 
       this.agents.set(key, {
-        config, channelId, agentId, sessionId: kimiSpawn.sessionId, proc,
+        config, teamId, agentId, sessionId: kimiSpawn.sessionId, proc,
         runtime: 'kimi', kimiState, kimiIdle: false,
       });
       this.starting.delete(key);
@@ -125,7 +125,7 @@ export class AgentManager {
         buffer = lines.pop();
         for (const line of lines) {
           if (!line.trim()) continue;
-          this._parseKimiLine(key, agentId, channelId, line, connection);
+          this._parseKimiLine(key, agentId, teamId, line, connection);
         }
       });
     } else if (runtime === 'codex') {
@@ -136,7 +136,7 @@ export class AgentManager {
       const codexSpawn = buildCodexSpawn({
         config,
         agentId,
-        channelId,
+        teamId,
         workspaceDir,
         chatBridgePath,
         serverUrl: this.serverUrl,
@@ -145,7 +145,7 @@ export class AgentManager {
         skills,
       });
 
-      console.log(`[AgentManager] Spawning codex for ${config.displayName ?? agentId} channel=${channelName ?? channelId ?? 'none'} (session=${config.sessionId ?? 'new'})`);
+      console.log(`[AgentManager] Spawning codex for ${config.displayName ?? agentId} team=${teamName ?? teamId ?? 'none'} (session=${config.sessionId ?? 'new'})`);
 
       proc = spawn('codex', codexSpawn.args, {
         cwd: workspaceDir,
@@ -154,7 +154,7 @@ export class AgentManager {
       });
 
       this.agents.set(key, {
-        config, channelId, agentId, sessionId: config.sessionId ?? null, proc,
+        config, teamId, agentId, sessionId: config.sessionId ?? null, proc,
         runtime: 'codex',
       });
       this.starting.delete(key);
@@ -166,7 +166,7 @@ export class AgentManager {
         buffer = lines.pop();
         for (const line of lines) {
           if (!line.trim()) continue;
-          this._parseCodexLine(key, agentId, channelId, line, connection);
+          this._parseCodexLine(key, agentId, teamId, line, connection);
         }
       });
     } else {
@@ -179,7 +179,7 @@ export class AgentManager {
             SERVER_URL: this.serverUrl,
             MACHINE_API_KEY: this.machineApiKey,
             AGENT_ID: agentId,
-            CHANNEL_ID: channelId ?? '',
+            TEAM_ID: teamId ?? '',
           },
         },
       };
@@ -235,7 +235,7 @@ export class AgentManager {
       const spawnEnv = { ...process.env, FORCE_COLOR: '0', ...(config.envVars ?? {}) };
       delete spawnEnv.CLAUDECODE;
 
-      console.log(`[AgentManager] Spawning claude for ${config.displayName ?? agentId} channel=${channelName ?? channelId ?? 'none'} (session=${config.sessionId ?? 'new'})`);
+      console.log(`[AgentManager] Spawning claude for ${config.displayName ?? agentId} team=${teamName ?? teamId ?? 'none'} (session=${config.sessionId ?? 'new'})`);
 
       proc = spawn('claude', args, {
         cwd: workspaceDir,
@@ -243,7 +243,7 @@ export class AgentManager {
         stdio: ['pipe', 'pipe', 'pipe'],
       });
 
-      this.agents.set(key, { config, channelId, agentId, sessionId: config.sessionId ?? null, proc, runtime: 'claude' });
+      this.agents.set(key, { config, teamId, agentId, sessionId: config.sessionId ?? null, proc, runtime: 'claude' });
       this.starting.delete(key);
 
       // Parse stdout stream for session ID and activity updates
@@ -254,24 +254,24 @@ export class AgentManager {
         buffer = lines.pop();
         for (const line of lines) {
           if (!line.trim()) continue;
-          this._parseLine(key, agentId, channelId, line, connection);
+          this._parseLine(key, agentId, teamId, line, connection);
         }
       });
     }
 
     proc.stderr.on('data', (data) => {
       const text = data.toString().trim();
-      if (text) console.error(`[AgentManager][${agentId}][${channelId}] stderr:`, text.slice(0, 300));
+      if (text) console.error(`[AgentManager][${agentId}][${teamId}] stderr:`, text.slice(0, 300));
     });
 
     proc.on('exit', (code) => {
       const agent = this.agents.get(key);
-      console.log(`[AgentManager] Agent ${agentId} channel=${channelId ?? 'none'} exited (code=${code})`);
+      console.log(`[AgentManager] Agent ${agentId} team=${teamId ?? 'none'} exited (code=${code})`);
       this.agents.delete(key);
 
       if (code === 0 && runtime === 'codex' && this._pendingMessages?.get(key)?.length) {
         const restartConfig = { ...config, sessionId: agent?.sessionId ?? config.sessionId ?? null };
-        this._startAgent({ agentId, channelId, config: restartConfig }, connection);
+        this._startAgent({ agentId, teamId, config: restartConfig }, connection);
         return;
       }
 
@@ -279,14 +279,14 @@ export class AgentManager {
       if (code !== 0 && config.sessionId && !this._retried?.has(key)) {
         if (!this._retried) this._retried = new Set();
         this._retried.add(key);
-        console.log(`[AgentManager] Retrying ${agentId} channel=${channelId} without session (session may not exist locally)`);
+        console.log(`[AgentManager] Retrying ${agentId} team=${teamId} without session (session may not exist locally)`);
         const retryConfig = { ...config, sessionId: null };
-        this._startAgent({ agentId, channelId, config: retryConfig }, connection);
+        this._startAgent({ agentId, teamId, config: retryConfig }, connection);
         return;
       }
 
-      connection.send({ type: 'agent:status', agentId, channelId, status: 'inactive' });
-      connection.send({ type: 'agent:activity', agentId, channelId, activity: 'offline', detail: '', entries: [] });
+      connection.send({ type: 'agent:status', agentId, teamId, status: 'inactive' });
+      connection.send({ type: 'agent:activity', agentId, teamId, activity: 'offline', detail: '', entries: [] });
     });
 
     // Send startup prompt
@@ -296,41 +296,41 @@ export class AgentManager {
       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, channelId, status: 'active' });
-    connection.send({ type: 'agent:activity', agentId, channelId, activity: 'online', detail: '', entries: [] });
+    connection.send({ type: 'agent:status', agentId, teamId, status: 'active' });
+    connection.send({ type: 'agent:activity', agentId, teamId, activity: 'online', detail: '', entries: [] });
 
     // Flush any messages that arrived while the agent was starting
     this._flushPending(key, connection);
   }
 
-  _stopAgent(agentId, channelId, connection) {
-    const key = this._key(agentId, channelId);
+  _stopAgent(agentId, teamId, connection) {
+    const key = this._key(agentId, teamId);
     const agent = this.agents.get(key);
     if (!agent) return;
-    console.log(`[AgentManager] Stopping agent ${agentId} channel=${channelId ?? 'none'}`);
+    console.log(`[AgentManager] Stopping agent ${agentId} team=${teamId ?? 'none'}`);
     agent.proc?.kill();
     // exit handler will report status
   }
 
   _deliverMessage(msg, connection) {
-    const { agentId, channelId, seq, message } = msg;
-    const key = this._key(agentId, channelId);
-    connection.send({ type: 'agent:deliver:ack', agentId, channelId, seq });
+    const { agentId, teamId, seq, message } = msg;
+    const key = this._key(agentId, teamId);
+    connection.send({ type: 'agent:deliver:ack', agentId, teamId, seq });
 
     if (!this.agents.has(key) && !this.starting.has(key)) {
       // Agent not running — queue the message and request config to spawn it
-      console.log(`[AgentManager] Agent ${agentId} channel=${channelId} not running, requesting start for seq=${seq}`);
+      console.log(`[AgentManager] Agent ${agentId.slice(0,8)} team=${message.team_name ?? teamId} not running, requesting start for seq=${seq}`);
       if (!this._pendingMessages) this._pendingMessages = new Map();
       const pending = this._pendingMessages.get(key) ?? [];
       pending.push(msg);
       this._pendingMessages.set(key, pending);
-      connection.send({ type: 'agent:request_start', agentId, channelId });
+      connection.send({ type: 'agent:request_start', agentId, teamId });
       return;
     }
 
     if (this.starting.has(key)) {
       // Spawn in progress — queue the message for delivery after start
-      console.log(`[AgentManager] Agent ${agentId} channel=${channelId} still starting, queuing seq=${seq}`);
+      console.log(`[AgentManager] Agent ${agentId.slice(0,8)} team=${message.team_name ?? teamId} still starting, queuing seq=${seq}`);
       if (!this._pendingMessages) this._pendingMessages = new Map();
       const pending = this._pendingMessages.get(key) ?? [];
       pending.push(msg);
@@ -339,7 +339,7 @@ export class AgentManager {
     }
 
     const text = this._formatDeliveryText(message);
-    console.log(`[AgentManager] Delivering seq=${seq} to agent ${agentId} channel=${channelId}`);
+    console.log(`[AgentManager] Delivering seq=${seq} to agent ${agent?.config?.displayName ?? agentId.slice(0,8)} team=${message.team_name ?? teamId}`);
     const agent = this.agents.get(key);
     if (agent?.runtime === 'codex') {
       if (!this._pendingMessages) this._pendingMessages = new Map();
@@ -358,9 +358,10 @@ export class AgentManager {
     if (!pending || pending.length === 0) return;
     this._pendingMessages.delete(key);
     for (const msg of pending) {
-      const { agentId, channelId, seq, message } = msg;
+      const { agentId, teamId, seq, message } = msg;
       const text = this._formatDeliveryText(message);
-      console.log(`[AgentManager] Flushing queued seq=${seq} to agent ${agentId} channel=${channelId}`);
+      const agent = this.agents.get(key);
+      console.log(`[AgentManager] Flushing queued seq=${seq} to agent ${agent?.config?.displayName ?? agentId.slice(0,8)} team=${message.team_name ?? teamId}`);
       this._write(key, text);
     }
   }
@@ -393,7 +394,7 @@ export class AgentManager {
     }
   }
 
-  _parseKimiLine(key, agentId, channelId, line, connection) {
+  _parseKimiLine(key, agentId, teamId, line, connection) {
     const agent = this.agents.get(key);
     if (!agent) return;
     const events = parseKimiLine(line, agent.kimiState);
@@ -402,18 +403,18 @@ export class AgentManager {
         case 'session_init':
           if (agent.sessionId !== evt.sessionId) {
             agent.sessionId = evt.sessionId;
-            connection.send({ type: 'agent:session', agentId, channelId, sessionId: evt.sessionId });
+            connection.send({ type: 'agent:session', agentId, teamId, sessionId: evt.sessionId });
           }
           break;
         case 'thinking':
-          connection.send({ type: 'agent:activity', agentId, channelId, activity: 'thinking', detail: '', entries: [] });
+          connection.send({ type: 'agent:activity', agentId, teamId, activity: 'thinking', detail: '', entries: [] });
           break;
         case 'tool_call':
-          connection.send({ type: 'agent:activity', agentId, channelId, activity: 'working', detail: evt.name, entries: [] });
+          connection.send({ type: 'agent:activity', agentId, teamId, activity: 'working', detail: evt.name, entries: [] });
           break;
         case 'turn_end':
           agent.kimiIdle = true;
-          connection.send({ type: 'agent:activity', agentId, channelId, activity: 'online', detail: '', entries: [] });
+          connection.send({ type: 'agent:activity', agentId, teamId, activity: 'online', detail: '', entries: [] });
           break;
         case 'error':
           console.error(`[AgentManager][kimi][${agentId}] Error: ${evt.message}`);
@@ -422,7 +423,7 @@ export class AgentManager {
     }
   }
 
-  _parseCodexLine(key, agentId, channelId, line, connection) {
+  _parseCodexLine(key, agentId, teamId, line, connection) {
     const agent = this.agents.get(key);
     if (!agent) return;
     const events = parseCodexLine(line);
@@ -431,17 +432,17 @@ export class AgentManager {
         case 'session_init':
           if (agent.sessionId !== evt.sessionId) {
             agent.sessionId = evt.sessionId;
-            connection.send({ type: 'agent:session', agentId, channelId, sessionId: evt.sessionId });
+            connection.send({ type: 'agent:session', agentId, teamId, sessionId: evt.sessionId });
           }
           break;
         case 'thinking':
-          connection.send({ type: 'agent:activity', agentId, channelId, activity: 'thinking', detail: '', entries: [] });
+          connection.send({ type: 'agent:activity', agentId, teamId, activity: 'thinking', detail: '', entries: [] });
           break;
         case 'tool_call':
-          connection.send({ type: 'agent:activity', agentId, channelId, activity: 'working', detail: evt.name, entries: [] });
+          connection.send({ type: 'agent:activity', agentId, teamId, activity: 'working', detail: evt.name, entries: [] });
           break;
         case 'turn_end':
-          connection.send({ type: 'agent:activity', agentId, channelId, activity: 'online', detail: '', entries: [] });
+          connection.send({ type: 'agent:activity', agentId, teamId, activity: 'online', detail: '', entries: [] });
           break;
         case 'error':
           console.error(`[AgentManager][codex][${agentId}] Error: ${evt.message}`);
@@ -450,7 +451,7 @@ export class AgentManager {
     }
   }
 
-  _parseLine(key, agentId, channelId, line, connection) {
+  _parseLine(key, agentId, teamId, line, connection) {
     let event;
     try { event = JSON.parse(line); }
     catch { return; }
@@ -460,7 +461,7 @@ export class AgentManager {
       const agent = this.agents.get(key);
       if (agent && agent.sessionId !== event.session_id) {
         agent.sessionId = event.session_id;
-        connection.send({ type: 'agent:session', agentId, channelId, sessionId: event.session_id });
+        connection.send({ type: 'agent:session', agentId, teamId, sessionId: event.session_id });
       }
     }
 
@@ -469,12 +470,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, channelId, activity: 'working', detail: toolName, entries: [] });
+        connection.send({ type: 'agent:activity', agentId, teamId, activity: 'working', detail: toolName, entries: [] });
       } else {
-        connection.send({ type: 'agent:activity', agentId, channelId, activity: 'thinking', detail: '', entries: [] });
+        connection.send({ type: 'agent:activity', agentId, teamId, activity: 'thinking', detail: '', entries: [] });
       }
     } else if (event.type === 'result') {
-      connection.send({ type: 'agent:activity', agentId, channelId, activity: 'online', detail: '', entries: [] });
+      connection.send({ type: 'agent:activity', agentId, teamId, activity: 'online', detail: '', entries: [] });
     }
   }
 }

package/src/chat-bridge.js

@@ -12,10 +12,10 @@ function getArg(name) {
 const SERVER_URL      = process.env.SERVER_URL || getArg('--server-url') || 'http://localhost:8777';
 const MACHINE_API_KEY = process.env.MACHINE_API_KEY || getArg('--auth-token') || '';
 const AGENT_ID        = process.env.AGENT_ID || getArg('--agent-id') || '';
-const CHANNEL_ID      = process.env.CHANNEL_ID || getArg('--channel-id') || '';  // injected per-channel at spawn time
+const TEAM_ID      = process.env.TEAM_ID || getArg('--team-id') || '';  // injected per-team at spawn time
 
-// Current active channelId for memory isolation (defaults to spawn-time CHANNEL_ID)
-let currentChannelId = CHANNEL_ID;
+// Current active teamId for memory isolation (defaults to spawn-time TEAM_ID)
+let currentTeamId = TEAM_ID;
 
 async function api(method, path, body) {
   const url = `${SERVER_URL}/internal/agent/${AGENT_ID}${path}`;
@@ -42,20 +42,20 @@ 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
+  // Track the teamId of the most recent message for memory isolation
   const lastMsg = msgs[msgs.length - 1];
-  if (lastMsg.channel_id) currentChannelId = lastMsg.channel_id;
+  if (lastMsg.team_id) currentTeamId = lastMsg.team_id;
 
   const text = msgs.map(m =>
-    `[${m.channel_type === 'dm' ? `dm:@${m.channel_name}` : `#${m.channel_name}`}] ${m.sender_name}: ${m.content}`
+    `[${m.team_type === 'dm' ? `dm:@${m.team_name}` : `#${m.team_name}`}] ${m.sender_name}: ${m.content}`
     + (m.task_status ? ` [task #${m.task_number} ${m.task_status}]` : '')
   ).join('\n');
   return { content: [{ type: 'text', text }] };
 });
 
 // ── send_message ──────────────────────────────────────────────────────────────
-server.tool('send_message', 'Send a message to a channel, DM, or thread', {
-  target:  z.string().describe('Target: #channel-name | dm:@agentName | #channel-name:shortMsgId'),
+server.tool('send_message', 'Send a message to a team, DM, or thread', {
+  target:  z.string().describe('Target: #team-name | dm:@agentName | #team-name:shortMsgId'),
   content: z.string().describe('Message content'),
 }, async ({ target, content }) => {
   const data = await api('POST', '/send', { target, content });
@@ -63,14 +63,14 @@ server.tool('send_message', 'Send a message to a channel, DM, or thread', {
 });
 
 // ── read_history ──────────────────────────────────────────────────────────────
-server.tool('read_history', 'Read message history from a channel, DM, or thread. Supports pagination via before/after and context jumps via around.', {
-  channel: z.string().describe('Target: #channel-name | dm:@agentName | #channel-name:shortMsgId'),
+server.tool('read_history', 'Read message history from a team, DM, or thread. Supports pagination via before/after and context jumps via around.', {
+  team: z.string().describe('Target: #team-name | dm:@agentName | #team-name:shortMsgId'),
   limit:   z.number().optional().describe('Max messages to return (default 50, max 100)'),
   around:  z.union([z.string(), z.number()]).optional().describe('Center the result window around a messageId or seq number'),
   before:  z.number().optional().describe('Return messages before this seq'),
   after:   z.number().optional().describe('Return messages after this seq'),
-}, async ({ channel, limit, around, before, after }) => {
-  const params = new URLSearchParams({ channel, limit: String(Math.min(limit ?? 50, 100)) });
+}, async ({ team, limit, around, before, after }) => {
+  const params = new URLSearchParams({ team, limit: String(Math.min(limit ?? 50, 100)) });
   if (around != null) params.set('around', String(around));
   if (before != null) params.set('before', String(before));
   if (after  != null) params.set('after',  String(after));
@@ -97,29 +97,29 @@ server.tool('read_history', 'Read message history from a channel, DM, or thread.
     }
   }
 
-  return { content: [{ type: 'text', text: `## History for ${channel} (${msgs.length} messages)\n\n${text}${footer}` }] };
+  return { content: [{ type: 'text', text: `## History for ${team} (${msgs.length} messages)\n\n${text}${footer}` }] };
 });
 
 // ── search_messages ──────────────────────────────────────────────────────────
-server.tool('search_messages', 'Search messages visible to you. Use this to find relevant conversations, then inspect a hit with read_history(channel=..., around=messageId).', {
+server.tool('search_messages', 'Search messages visible to you. Use this to find relevant conversations, then inspect a hit with read_history(team=..., around=messageId).', {
   query:   z.string().describe('Search query'),
-  channel: z.string().optional().describe('Optional target to scope the search, e.g. "#general", "dm:@richard"'),
+  team: z.string().optional().describe('Optional target to scope the search, e.g. "#general", "dm:@richard"'),
   limit:   z.number().optional().describe('Max results (default 10, max 20)'),
-}, async ({ query, channel, limit }) => {
+}, async ({ query, team, limit }) => {
   const trimmed = query.trim();
   if (!trimmed) return { content: [{ type: 'text', text: 'Search query cannot be empty.' }] };
   const params = new URLSearchParams({ q: trimmed, limit: String(Math.min(limit ?? 10, 20)) });
-  if (channel) params.set('channel', channel);
+  if (team) params.set('team', team);
   try {
     const data = await api('GET', `/search?${params}`);
     if (!data.results || data.results.length === 0)
       return { content: [{ type: 'text', text: 'No search results.' }] };
     const formatted = data.results.map((r, i) => [
       `[${i + 1}] msg=${r.id} seq=${r.seq} time=${r.createdAt}`,
-      `channel: #${r.channelName}`,
+      `team: #${r.teamName}`,
       `sender: @${r.senderName}${r.senderType === 'agent' ? ' (agent)' : ''}`,
       `content: ${r.snippet}`,
-      `next: read_history(channel="#${r.channelName}", around="${r.id}", limit=20)`,
+      `next: read_history(team="#${r.teamName}", around="${r.id}", limit=20)`,
     ].join('\n')).join('\n\n');
     return { content: [{ type: 'text', text: `## Search Results for "${trimmed}" (${data.results.length} results)\n\n${formatted}` }] };
   } catch (err) {
@@ -160,20 +160,20 @@ server.tool('view_file', 'Download an attached image by its attachment ID and sa
 });
 
 // ── list_server ───────────────────────────────────────────────────────────────
-server.tool('list_server', 'List channels, agents, and humans on the server', {}, async () => {
+server.tool('list_server', 'List teams, agents, and humans on the server', {}, async () => {
   const data = await api('GET', '/server');
-  const channels = (data.channels ?? []).map(c => `  #${c.name}${c.joined ? ' (joined)' : ''} — ${c.description}`).join('\n');
+  const teams = (data.teams ?? []).map(c => `  #${c.name}${c.joined ? ' (joined)' : ''} — ${c.description}`).join('\n');
   const agents   = (data.agents   ?? []).map(a => `  @${a.name} [${a.status}]`).join('\n');
   const humans   = (data.humans   ?? []).map(h => `  @${h.name}`).join('\n');
-  return { content: [{ type: 'text', text: `Channels:\n${channels}\n\nAgents:\n${agents}\n\nHumans:\n${humans}` }] };
+  return { content: [{ type: 'text', text: `Teams:\n${teams}\n\nAgents:\n${agents}\n\nHumans:\n${humans}` }] };
 });
 
 // ── list_tasks ────────────────────────────────────────────────────────────────
-server.tool('list_tasks', 'List tasks in a channel', {
-  channel: z.string().describe('Target: #channel-name'),
+server.tool('list_tasks', 'List tasks in a team', {
+  team: z.string().describe('Target: #team-name'),
   status:  z.enum(['all', 'todo', 'in_progress', 'in_review', 'done']).optional(),
-}, async ({ channel, status }) => {
-  const params = new URLSearchParams({ channel, status: status ?? 'all' });
+}, async ({ team, status }) => {
+  const params = new URLSearchParams({ team, status: status ?? 'all' });
   const data = await api('GET', `/tasks?${params}`);
   const tasks = data.tasks ?? [];
   if (tasks.length === 0) return { content: [{ type: 'text', text: 'No tasks found.' }] };
@@ -186,22 +186,22 @@ server.tool('list_tasks', 'List tasks in a channel', {
 });
 
 // ── create_tasks ──────────────────────────────────────────────────────────────
-server.tool('create_tasks', 'Create one or more tasks in a channel', {
-  channel: z.string().describe('Target: #channel-name'),
+server.tool('create_tasks', 'Create one or more tasks in a team', {
+  team: z.string().describe('Target: #team-name'),
   tasks:   z.array(z.object({ title: z.string() })).describe('Array of tasks to create'),
-}, async ({ channel, tasks }) => {
-  const data = await api('POST', '/tasks', { channel, tasks });
+}, async ({ team, tasks }) => {
+  const data = await api('POST', '/tasks', { team, tasks });
   const created = (data.tasks ?? []).map(t => `#${t.taskNumber} ${t.title}`).join('\n');
   return { content: [{ type: 'text', text: `Created:\n${created}` }] };
 });
 
 // ── claim_tasks ───────────────────────────────────────────────────────────────
 server.tool('claim_tasks', 'Claim one or more tasks to work on', {
-  channel:      z.string().describe('Target: #channel-name'),
+  team:         z.string().describe('Target: #team-name'),
   task_numbers: z.array(z.number()).optional().describe('Task numbers to claim'),
   message_ids:  z.array(z.string()).optional().describe('Short message IDs to claim'),
-}, async ({ channel, task_numbers, message_ids }) => {
-  const data = await api('POST', '/tasks/claim', { channel, task_numbers, message_ids });
+}, async ({ team, task_numbers, message_ids }) => {
+  const data = await api('POST', '/tasks/claim', { team, task_numbers, message_ids });
   const results = (data.results ?? []).map(r =>
     `#${r.taskNumber}: ${r.success ? 'claimed' : `failed (${r.reason})`}`
   ).join('\n');
@@ -210,26 +210,26 @@ server.tool('claim_tasks', 'Claim one or more tasks to work on', {
 
 // ── unclaim_task ──────────────────────────────────────────────────────────────
 server.tool('unclaim_task', 'Release a claimed task', {
-  channel:     z.string().describe('Target: #channel-name'),
+  team:        z.string().describe('Target: #team-name'),
   task_number: z.number().describe('Task number to unclaim'),
-}, async ({ channel, task_number }) => {
-  await api('POST', '/tasks/unclaim', { channel, task_number });
+}, async ({ team, task_number }) => {
+  await api('POST', '/tasks/unclaim', { team, task_number });
   return { content: [{ type: 'text', text: `Task #${task_number} unclaimed.` }] };
 });
 
 // ── update_task_status ────────────────────────────────────────────────────────
 server.tool('update_task_status', 'Update the status of a task', {
-  channel:     z.string().describe('Target: #channel-name'),
+  team:        z.string().describe('Target: #team-name'),
   task_number: z.number().describe('Task number'),
   status:      z.enum(['todo', 'in_progress', 'in_review', 'done']).describe('New status'),
-}, async ({ channel, task_number, status }) => {
-  await api('POST', '/tasks/update-status', { channel, task_number, status });
+}, async ({ team, task_number, status }) => {
+  await api('POST', '/tasks/update-status', { team, task_number, status });
   return { content: [{ type: 'text', text: `Task #${task_number} → ${status}` }] };
 });
 
 // ── list_memory ───────────────────────────────────────────────────────────────
-server.tool('list_memory', 'List all memory files stored for this agent in the current channel', {}, async () => {
-  const chParam = currentChannelId ? `&channelId=${encodeURIComponent(currentChannelId)}` : '';
+server.tool('list_memory', 'List all memory files stored for this agent in the current team', {}, async () => {
+  const chParam = currentTeamId ? `&teamId=${encodeURIComponent(currentTeamId)}` : '';
   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.' }] };
@@ -238,9 +238,9 @@ server.tool('list_memory', 'List all memory files stored for this agent in the c
 
 // ── read_memory ───────────────────────────────────────────────────────────────
 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"'),
+  path: z.string().describe('File path, e.g. "MEMORY.md" or "notes/teams.md"'),
 }, async ({ path }) => {
-  const chParam = currentChannelId ? `&channelId=${encodeURIComponent(currentChannelId)}` : '';
+  const chParam = currentTeamId ? `&teamId=${encodeURIComponent(currentTeamId)}` : '';
   try {
     const data = await api('GET', `/memory?path=${encodeURIComponent(path)}${chParam}`);
     return { content: [{ type: 'text', text: data.content }] };
@@ -255,14 +255,14 @@ 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 }) => {
-  const chParam = currentChannelId ? `&channelId=${encodeURIComponent(currentChannelId)}` : '';
+  const chParam = currentTeamId ? `&teamId=${encodeURIComponent(currentTeamId)}` : '';
   await api('PUT', `/memory?path=${encodeURIComponent(path)}${chParam}`, { content });
   return { content: [{ type: 'text', text: `Saved ${path}` }] };
 });
 
 // ── skill_list ───────────────────────────────────────────────────────────────
 server.tool('skill_list', 'List all skills available to you (platform + bound). Returns index only (name + description), not full content.', {}, async () => {
-  const chParam = currentChannelId ? `?channelId=${encodeURIComponent(currentChannelId)}` : '';
+  const chParam = currentTeamId ? `?teamId=${encodeURIComponent(currentTeamId)}` : '';
   const skills = await api('GET', `/skills${chParam}`);
   if (!skills || skills.length === 0) return { content: [{ type: 'text', text: 'No skills available.' }] };
   const lines = skills.map(s => `- [${s.type}] **${s.name}** — ${s.description}`);
@@ -283,16 +283,16 @@ server.tool('skill_read', 'Read the full content of a skill by name or ID', {
 });
 
 // ── skill_create ─────────────────────────────────────────────────────────────
-server.tool('skill_create', 'Create a new reusable skill from what you have learned. Auto-binds to the current channel.', {
+server.tool('skill_create', 'Create a new reusable skill from what you have learned. Auto-binds to the current team.', {
   name:        z.string().describe('Short skill name (lowercase, hyphens ok), e.g. "xhs-posting"'),
   description: z.string().describe('One-line description of what this skill covers'),
   content:     z.string().describe('Full skill content in markdown — procedures, steps, tips'),
   tags:        z.array(z.string()).optional().describe('Optional tags for categorization'),
 }, async ({ name, description, content, tags }) => {
   const body = { name, description, content, tags: tags ?? [] };
-  if (currentChannelId) body.channelId = currentChannelId;
+  if (currentTeamId) body.teamId = currentTeamId;
   const result = await api('POST', '/skills', body);
-  return { content: [{ type: 'text', text: `Skill "${result.name}" created and bound to current channel.` }] };
+  return { content: [{ type: 'text', text: `Skill "${result.name}" created and bound to current team.` }] };
 });
 
 // ── skill_update ─────────────────────────────────────────────────────────────

package/src/drivers/claude.js

@@ -13,12 +13,12 @@ Your workspace and MEMORY.md persist across turns, so you can recover context wh
 You have MCP tools from the "chat" server. Use ONLY these for communication:
 
 1. **${t("check_messages")}** — Non-blocking check for new messages. Use freely during work — at natural breakpoints or after notifications.
-2. **${t("send_message")}** — Send a message to a channel or DM.
-3. **${t("list_server")}** — List all channels in this server, which ones you have joined, plus all agents and humans.
-4. **${t("read_history")}** — Read past messages from a channel, DM, or thread. Supports \`before\` / \`after\` pagination and \`around\` for centered context.
+2. **${t("send_message")}** — Send a message to a team or DM.
+3. **${t("list_server")}** — List all teams in this server, which ones you have joined, plus all agents and humans.
+4. **${t("read_history")}** — Read past messages from a team, DM, or thread. Supports \`before\` / \`after\` pagination and \`around\` for centered context.
 5. **${t("search_messages")}** — Search messages visible to you, then inspect a hit with \`${t("read_history")}\`.
-6. **${t("list_tasks")}** — View a channel's task board.
-7. **${t("create_tasks")}** — Create new task-messages in a channel (supports batch; equivalent to sending a new message and publishing it as a task-message, not claiming it for yourself).
+6. **${t("list_tasks")}** — View a team's task board.
+7. **${t("create_tasks")}** — Create new task-messages in a team (supports batch; equivalent to sending a new message and publishing it as a task-message, not claiming it for yourself).
 8. **${t("claim_tasks")}** — Claim tasks by number (supports batch, handles conflicts).
 9. **${t("unclaim_task")}** — Release your claim on a task.
 10. **${t("update_task_status")}** — Change a task's status (e.g. to in_review or done).
@@ -58,40 +58,40 @@ Header fields:
 
 ### Sending messages
 
-- **Reply to a channel**: \`send_message(target="#channel-name", content="...")\`
+- **Reply to a team**: \`send_message(target="#team-name", content="...")\`
 - **Reply to a DM**: \`send_message(target="dm:@peer-name", content="...")\`
-- **Reply in a thread**: \`send_message(target="#channel:shortid", content="...")\` or \`send_message(target="dm:@peer:shortid", content="...")\`
+- **Reply in a thread**: \`send_message(target="#team:shortid", content="...")\` or \`send_message(target="dm:@peer:shortid", content="...")\`
 - **Start a NEW DM**: \`send_message(target="dm:@person-name", content="...")\`
 
-**IMPORTANT**: To reply to any message, always reuse the exact \`target\` from the received message. This ensures your reply goes to the right place — whether it's a channel, DM, or thread.
+**IMPORTANT**: To reply to any message, always reuse the exact \`target\` from the received message. This ensures your reply goes to the right place — whether it's a team, DM, or thread.
 
 ### Threads
 
-Threads are sub-conversations attached to a specific message. They let you discuss a topic without cluttering the main channel.
+Threads are sub-conversations attached to a specific message. They let you discuss a topic without cluttering the main team.
 
 - **Thread targets** have a colon and short ID suffix: \`#general:a1b2c3d4\` (thread in #general) or \`dm:@richard:x9y8z7a0\` (thread in a DM).
 - When you receive a message from a thread (the target has a \`:shortid\` suffix), **always reply using that same target** to keep the conversation in the thread.
 - **Start a new thread**: Use the \`msg=\` field from the header as the thread suffix. For example, if you see \`[target=#general msg=a1b2c3d4 ...]\`, reply with \`send_message(target="#general:a1b2c3d4", content="...")\`. The thread will be auto-created if it doesn't exist yet.
 - When you send a message, the response includes the message ID. You can use it to start a thread on your own message.
-- You can read thread history: \`read_history(channel="#general:a1b2c3d4")\`
+- You can read thread history: \`read_history(team="#general:a1b2c3d4")\`
 - Threads cannot be nested — you cannot start a thread inside a thread.
 
-### Discovering people and channels
+### Discovering people and teams
 
-Call \`list_server\` to see all channels in this server, which ones you have joined, other agents, and humans.
+Call \`list_server\` to see all teams in this server, which ones you have joined, other agents, and humans.
 
-### Channel awareness
+### Team awareness
 
-Each channel has a **name** and optionally a **description** that define its purpose (visible via \`list_server\`). Respect them:
-- **Reply in context** — always respond in the channel/thread the message came from.
-- **Stay on topic** — when proactively sharing results or updates, post in the channel most relevant to the work. Don't scatter messages across unrelated channels.
-- If unsure where something belongs, call \`list_server\` to review channel descriptions.
+Each team has a **name** and optionally a **description** that define its purpose (visible via \`list_server\`). Respect them:
+- **Reply in context** — always respond in the team/thread the message came from.
+- **Stay on topic** — when proactively sharing results or updates, post in the team most relevant to the work. Don't scatter messages across unrelated teams.
+- If unsure where something belongs, call \`list_server\` to review team descriptions.
 
 ### Reading history
 
-\`read_history(channel="#channel-name")\` or \`read_history(channel="dm:@peer-name")\` or \`read_history(channel="#channel:shortid")\`
+\`read_history(team="#team-name")\` or \`read_history(team="dm:@peer-name")\` or \`read_history(team="#team:shortid")\`
 
-To jump directly to a specific hit with nearby context, use \`read_history(channel="...", around="messageId")\` or \`read_history(channel="...", around=12345)\`.
+To jump directly to a specific hit with nearby context, use \`read_history(team="...", around="messageId")\` or \`read_history(team="...", around=12345)\`.
 
 ### Tasks
 
@@ -104,7 +104,7 @@ When someone sends a message that asks you to do something — fix a bug, write
 - A regular message (no task suffix): \`@Alice: Can someone look into the login bug?\`
 - A system notification about task changes: \`📋 Alice converted a message to task #3 "Fix the login bug"\`
 
-Only top-level channel / DM messages can become tasks. Messages inside threads are discussion context — reply there, but keep claims and conversions to top-level messages.
+Only top-level team / DM messages can become tasks. Messages inside threads are discussion context — reply there, but keep claims and conversions to top-level messages.
 
 \`read_history\` shows messages in their current state. If a message was later converted to a task, it will show the \`[task #N ...]\` suffix.
 
@@ -115,7 +115,7 @@ Only top-level channel / DM messages can become tasks. Messages inside threads a
 **Workflow:**
 1. Receive a message that requires action → claim it first (by task number if already a task, or by message ID if it's a regular message)
 2. If the claim fails, someone else is working on it — move on to another task
-3. Post updates in the task's thread: \`send_message(target="#channel:msgShortId", ...)\`
+3. Post updates in the task's thread: \`send_message(target="#team:msgShortId", ...)\`
 4. When done, set status to \`in_review\` so a human can validate
 5. After approval (e.g. "looks good", "merge it"), set status to \`done\`
 
@@ -145,12 +145,12 @@ When you receive a notification about new tasks, check the task board and claim
 
 ## @Mentions
 
-In channel group chats, you can @mention people by their unique name (e.g. "@alice" or "@bob").
+In team group chats, you can @mention people by their unique name (e.g. "@alice" or "@bob").
 - Your stable Lightcone @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.
+- @mentions only reach people inside the team — teams are the isolation boundary.
 
 ## Communication style
 
@@ -166,14 +166,14 @@ Keep the user informed. They cannot see your internal reasoning, so:
 - **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 \`${t("claim_tasks")}\` before doing any work on a task. If the claim fails, stop immediately and pick a different task.
-- **Before stopping, check for concrete blockers you own.** If you still owe a specific handoff, review, decision, or reply that is currently blocking a specific person, send one minimal actionable message to that person or channel before stopping.
+- **Before stopping, check for concrete blockers you own.** If you still owe a specific handoff, review, decision, or reply that is currently blocking a specific person, send one minimal actionable message to that person or team before stopping.
 - **Skip idle narration.** Only send messages when you have actionable content — avoid broadcasting that you are waiting or idle.
 
 ### Formatting — No HTML
 
-Use plain-text @mentions (e.g. \`@alice\`) and #channel references (e.g. \`#general\`, \`#1\`) — no HTML tags.
+Use plain-text @mentions (e.g. \`@alice\`) and #team references (e.g. \`#general\`, \`#1\`) — no HTML tags.
 
-When referencing a channel or mentioning someone, write them as plain text without backticks. Backtick-wrapped mentions render as code instead of interactive links.
+When referencing a team or mentioning someone, write them as plain text without backticks. Backtick-wrapped mentions render as code instead of interactive links.
 
 ### Formatting — URLs in non-English text
 
@@ -210,7 +210,7 @@ Your memory is stored on the server and persists across machines and restarts. U
 
 ## Key Knowledge
 - Read notes/user-preferences.md for user preferences and conventions
-- Read notes/channels.md for what each channel is about and ongoing work
+- Read notes/teams.md for what each team is about and ongoing work
 - Read notes/domain.md for domain-specific knowledge and conventions
 - ...
 
@@ -227,7 +227,7 @@ Your memory is stored on the server and persists across machines and restarts. U
 2. **World/project context** — The project structure, tech stack, architectural decisions, team conventions, deployment patterns.
 3. **Domain knowledge** — Domain-specific terminology, conventions, best practices you learn through tasks.
 4. **Work history** — What has been done, decisions made and why, problems solved, approaches that worked or failed.
-5. **Channel context** — What each channel is about, who participates, what's being discussed, ongoing tasks per channel.
+5. **Team context** — What each team is about, who participates, what's being discussed, ongoing tasks per team.
 6. **Other agents** — What other agents do, their specialties, collaboration patterns, how to work with them effectively.
 
 ### How to organize memory
@@ -235,7 +235,7 @@ Your memory is stored on the server and persists across machines and restarts. U
 - **MEMORY.md** is always the index. Keep it concise but comprehensive as a table of contents.
 - Create a \`notes/\` directory for detailed knowledge files. Use descriptive names:
   - \`notes/user-preferences.md\` — User's preferences and conventions
-  - \`notes/channels.md\` — Summary of each channel and its purpose
+  - \`notes/teams.md\` — Summary of each team and its purpose
   - \`notes/work-log.md\` — Important decisions and completed work
   - \`notes/<domain>.md\` — Domain-specific knowledge
 - You can also create any other files or directories for your work (scripts, notes, data, etc.)
@@ -250,7 +250,7 @@ Your context will be periodically compressed to stay within limits. When this ha
 - **MEMORY.md must be self-sufficient as a recovery point.** After reading it, you should be able to understand who you are, what you know, and what you were working on.
 - **Before a long task**, write a brief "Active Context" note in MEMORY.md so you can resume if interrupted mid-task.
 - **After completing work**, update your notes and MEMORY.md index so nothing is lost.
-- Keep MEMORY.md complete enough that context compression preserves: which channel is about what, what tasks are in progress, what the user has asked for, and what other agents are doing.
+- Keep MEMORY.md complete enough that context compression preserves: which team is about what, what tasks are in progress, what the user has asked for, and what other agents are doing.
 
 ## Capabilities
 
@@ -277,11 +277,11 @@ Your agent ID is: ${agentId}
 const DATA_FETCHER_PROMPT = `
 ## 你的专属职责：获取数据
 
-你是内容发布流水线的第一环。当 #content-publish 频道收到用户的职位推广需求时，你负责从职位数据库查询数据并输出结构化结果。
+你是内容发布流水线的第一环。当 #content-publish 团队收到用户的职位推广需求时，你负责从职位数据库查询数据并输出结构化结果。
 
 ### 工作流程
 
-1. 监听 #content-publish 频道的用户消息
+1. 监听 #content-publish 团队的用户消息
 2. 识别用户需求（如"推广 Java 后端实习岗位"、"帮我发一下腾讯的产品经理职位"）
 3. 使用 MySQL MCP 工具查询职位数据：
    - \`mcp__mysql__search_jobs\` — 按关键词/公司/类型/地点搜索
@@ -323,7 +323,7 @@ const COPYWRITER_PROMPT = `
 
 ### 工作流程
 
-1. 监听 #content-publish 频道，等待包含【职位数据已就绪】标记的消息
+1. 监听 #content-publish 团队，等待包含【职位数据已就绪】标记的消息
 2. 仔细阅读职位详情，提炼核心卖点
 3. 撰写小红书风格图文（风格活泼、有吸引力、适合年轻求职者）
 4. 将文案发到频道，并 @designer 接力
@@ -380,7 +380,7 @@ const DESIGNER_PROMPT = `
 
 ### 工作流程
 
-1. 监听 #content-publish 频道，等待包含【文案已就绪】标记的消息
+1. 监听 #content-publish 团队，等待包含【文案已就绪】标记的消息
 2. 提取文案中的核心信息和设计要点
 3. 编写 Node.js 代码，使用 canvas 或 Puppeteer（渲染 HTML）生成图片
 4. 执行代码，生成图片文件到工作目录
@@ -535,7 +535,7 @@ Use \`skill_read\` to load full content when needed.
 - Load a skill's full procedure: \`skill_read({ name: "skill-name" })\`
 - After completing a complex task (5+ tool calls), consider saving it as a skill: \`skill_create({ name, description, content })\`
 - When using a skill and finding it outdated or wrong, update it immediately: \`skill_update({ name, content })\`
-- Skills you create are automatically shared with other agents in the same channel
+- Skills you create are automatically shared with other agents in the same team
 
 ### Available Skills
 `;

package/src/drivers/codex.js

@@ -3,14 +3,14 @@ import { existsSync } from 'fs';
 import path from 'path';
 import { buildSystemPrompt as buildClaudeSystemPrompt } from './claude.js';
 
-function buildChatBridgeArgs(chatBridgePath, { agentId, channelId, serverUrl, authToken }) {
+function buildChatBridgeArgs(chatBridgePath, { agentId, teamId, serverUrl, authToken }) {
   const args = [
     chatBridgePath,
     '--agent-id', agentId,
     '--server-url', serverUrl,
     '--auth-token', authToken,
   ];
-  if (channelId) args.push('--channel-id', channelId);
+  if (teamId) args.push('--team-id', teamId);
   return args;
 }
 
@@ -62,7 +62,7 @@ export function buildCodexSystemPrompt(config, agentId) {
 }
 
 export function buildCodexSpawn({
-  config, agentId, channelId, workspaceDir, chatBridgePath, serverUrl, machineApiKey, prompt, skills,
+  config, agentId, teamId, workspaceDir, chatBridgePath, serverUrl, machineApiKey, prompt, skills,
 }) {
   ensureGitRepo(workspaceDir);
 
@@ -73,7 +73,7 @@ export function buildCodexSpawn({
 
   const bridgeArgs = buildChatBridgeArgs(chatBridgePath, {
     agentId,
-    channelId,
+    teamId,
     serverUrl,
     authToken: config.authToken || machineApiKey,
   });

package/src/drivers/kimi.js

@@ -12,7 +12,7 @@ const KIMI_MCP_FILE = '.lightcone-kimi-mcp.json';
  * Build Kimi CLI spawn args and config files.
  * Returns { args, env, setupFiles() } ready for spawn('kimi', args, { env }).
  */
-export function buildKimiSpawn({ config, agentId, channelId, workspaceDir, chatBridgePath, serverUrl, machineApiKey, skills }) {
+export function buildKimiSpawn({ config, agentId, teamId, workspaceDir, chatBridgePath, serverUrl, machineApiKey, skills }) {
   const isResume = !!config.sessionId;
   const sessionId = config.sessionId || randomUUID();
 
@@ -46,7 +46,7 @@ export function buildKimiSpawn({ config, agentId, channelId, workspaceDir, chatB
         SERVER_URL: serverUrl,
         MACHINE_API_KEY: machineApiKey,
         AGENT_ID: agentId,
-        CHANNEL_ID: channelId ?? '',
+        TEAM_ID: teamId ?? '',
       },
     },
   };