@lightcone-ai/daemon 0.9.78 → 0.10.0

package/src/agent-manager.js

@@ -1,34 +1,67 @@
 import { spawn } from 'child_process';
-import { mkdirSync, statSync, writeFileSync, readdirSync, unlinkSync } from 'fs';
+import { mkdirSync, writeFileSync, readdirSync, unlinkSync } from 'fs';
 import { homedir } from 'os';
 import path from 'path';
-import { buildSystemPrompt } from './drivers/claude.js';
-import { buildCodexSpawn, buildCodexSystemPrompt, parseCodexLine } from './drivers/codex.js';
-import { buildKimiSpawn, buildKimiInitMessages, parseKimiLine, encodeKimiStdin } from './drivers/kimi.js';
+import { parseCodexLine, adaptCodexSystemPrompt } from './drivers/codex.js';
+import { parseKimiLine, encodeKimiStdin } from './drivers/kimi.js';
 import { startSession, stopSession, stopAllSessions } from './browser-login.js';
-import { buildSkillMcpServers } from './mcp-config.js';
+import { markInvalidatedLeases } from './governance-state.js';
+
+const KIMI_SYSTEM_PROMPT_FILE = '.lightcone-kimi-system.md';
+const KIMI_AGENT_FILE = '.lightcone-kimi-agent.yaml';
+const KIMI_MCP_FILE = '.lightcone-kimi-mcp.json';
+
+function runtimeMissingDetail(runtime) {
+  return `cli_missing:${runtime}`;
+}
+
+function resolveExitOfflineDetail({ code, signal, stopCause }) {
+  if (stopCause === 'manual_stop') return '';
+  if (stopCause === 'credential_revoked') return 'credential_revoked';
+  if (code === 0) return '';
+  if (signal === 'SIGTERM') return '';
+  if (signal === 'SIGKILL') return 'agent_timeout';
+  return 'spawn_session_crashed';
+}
+
+function normalizeObject(value) {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+
+function replacePlaceholders(text, replacements) {
+  if (typeof text !== 'string') return text;
+  let next = text;
+  for (const [token, value] of Object.entries(replacements)) {
+    next = next.split(token).join(value);
+  }
+  return next;
+}
 
 export class AgentManager {
   constructor({ serverUrl, machineApiKey }) {
     this.serverUrl = serverUrl;
     this.machineApiKey = machineApiKey;
-    // key: `teamId:agentId` → { config, teamId, agentId, sessionId, proc }
+    // key: `workspaceId:agentId` → { config, workspaceId, agentId, sessionId, proc }
     this.agents = new Map();
     // key → true (spawn in progress)
     this.starting = new Set();
+    this.directiveRefreshTimers = new Map();
+    this.directiveGovernanceCache = new Map();
   }
 
-  _key(agentId, teamId) {
-    return `${teamId ?? ''}:${agentId}`;
+  _key(agentId, workspaceId) {
+    return `${workspaceId ?? ''}:${agentId}`;
   }
 
   handle(msg, connection) {
     switch (msg.type) {
       case 'agent:start':       return this._startAgent(msg, connection);
-      case 'agent:stop':        return this._stopAgent(msg.agentId, msg.teamId, connection);
+      case 'agent:stop':        return this._stopAgent(msg.agentId, msg.workspaceId, connection);
       case 'agent:deliver':     return this._deliverMessage(msg, connection);
       case 'browser:start_login': return this._startBrowserLogin(msg, connection);
       case 'browser:stop_login':  return this._stopBrowserLogin(msg);
+      case 'policy_invalidate':   return this._handlePolicyInvalidate(msg, connection);
+      case 'credential_revoked':  return this._handleCredentialRevoked(msg, connection);
       case 'ping':              return connection.send({ type: 'pong' });
       default:
         console.log(`[AgentManager] Unhandled: ${msg.type}`);
@@ -36,6 +69,10 @@ export class AgentManager {
   }
 
   async stopAll() {
+    for (const timer of this.directiveRefreshTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.directiveRefreshTimers.clear();
     for (const [, agent] of this.agents) {
       if (agent.proc) agent.proc.kill();
     }
@@ -45,16 +82,16 @@ export class AgentManager {
 
   // ── private ───────────────────────────────────────────────────────────────
 
-  _teamWorkspaceDir(teamId) {
-    const dir = path.join(homedir(), '.lightcone', 'workspace', teamId ?? '_global');
+  _workspaceRootDir(workspaceId) {
+    const dir = path.join(homedir(), '.lightcone', 'workspace', workspaceId ?? '_global');
     mkdirSync(path.join(dir, 'artifacts'), { recursive: true });
     mkdirSync(path.join(dir, 'notes'), { recursive: true });
     mkdirSync(path.join(dir, 'tmp'), { recursive: true });
     return dir;
   }
 
-  _workspaceDir(agentId, teamId) {
-    const dir = path.join(homedir(), '.lightcone', 'workspace', teamId ?? '_global', agentId);
+  _workspaceDir(agentId, workspaceId) {
+    const dir = path.join(homedir(), '.lightcone', 'workspace', workspaceId ?? '_global', agentId);
     mkdirSync(dir, { recursive: true });
     mkdirSync(path.join(dir, 'tmp'), { recursive: true });
     return dir;
@@ -78,7 +115,7 @@ export class AgentManager {
   }
 
   _formatDeliveryText(message) {
-    return `New message in ${message.team_type === 'dm' ? 'dm from' : `#${message.team_name} from`} ${message.sender_name}: ${message.content}`;
+    return `New message in ${message.workspace_type === 'dm' ? 'dm from' : `#${message.workspace_name} from`} ${message.sender_name}: ${message.content}`;
   }
 
   _takePendingMessage(key) {
@@ -90,81 +127,597 @@ export class AgentManager {
     return msg;
   }
 
-  async _startAgent({ agentId, teamId, teamName, config }, connection) {
-    const key = this._key(agentId, teamId);
+  _prepareStartupMessage(key, runtime) {
+    if (runtime === 'codex') {
+      const startupMsg = this._takePendingMessage(key);
+      return { startupMsg, directiveMsg: startupMsg };
+    }
+    const pending = this._pendingMessages?.get(key);
+    return {
+      startupMsg: null,
+      directiveMsg: pending?.[0] ?? null,
+    };
+  }
+
+  _resolveDirectiveArgPath(arg, { chatBridgePath }) {
+    if (typeof arg !== 'string') return arg;
+    const normalized = arg.replaceAll('\\', '/');
+    if (normalized.includes('chat-bridge.js')) {
+      return chatBridgePath;
+    }
+    if (normalized.includes('/mcp-servers/publisher/index.js')) {
+      return new URL('../mcp-servers/publisher/index.js', import.meta.url).pathname;
+    }
+    if (normalized.includes('/mcp-servers/workspace-migrate/index.js')) {
+      return new URL('../../mcp-servers/workspace-migrate/index.js', import.meta.url).pathname;
+    }
+    if (normalized.includes('/mcp-servers/mysql/index.js')) {
+      return new URL('../../mcp-servers/mysql/index.js', import.meta.url).pathname;
+    }
+    if (normalized.includes('/mcp-servers/platform/index.js')) {
+      return new URL('../../mcp-servers/platform/index.js', import.meta.url).pathname;
+    }
+    return arg;
+  }
+
+  _normalizeDirectiveForLocalSpawn(directive, {
+    agentId,
+    workspaceId,
+    workspaceDir,
+    chatBridgePath,
+    config,
+  }) {
+    const authToken = config?.authToken || this.machineApiKey;
+    const userId = config?.userId ?? 'default';
+    const profileRoot = path.join(homedir(), '.lightcone', 'chrome-profiles');
+    const replacements = {
+      '${SERVER_URL}': this.serverUrl,
+      '${MACHINE_API_KEY}': authToken,
+      '${AGENT_ID}': agentId,
+      '${WORKSPACE_ID}': workspaceId ?? '',
+      '${WORKSPACE_DIR}': workspaceDir,
+      '${XHS_PROFILE_DIR}': path.join(profileRoot, `xhs-${userId}`),
+      '${DOUYIN_PROFILE_DIR}': path.join(profileRoot, `douyin-${userId}`),
+      '${KUAISHOU_PROFILE_DIR}': path.join(profileRoot, `kuaishou-${userId}`),
+    };
+
+    const normalized = this._replaceDirectiveValue(normalizeObject(directive), replacements);
+    const mcpServers = normalizeObject(normalized.mcp_servers);
+    const governanceLease = normalizeObject(normalized.policy_lease);
+    const leaseValidUntil = Date.parse(governanceLease.valid_until ?? '');
+    const leaseState = Number.isFinite(leaseValidUntil) && leaseValidUntil > Date.now() ? 'valid' : 'expired';
+    const governanceEnv = normalized.spawn_bundle_id || normalized.policy_version || normalized.directive_id
+      ? {
+          LC_GOVERNANCE_DIRECTIVE_ID: normalized.directive_id ?? '',
+          LC_GOVERNANCE_SPAWN_BUNDLE_ID: normalized.spawn_bundle_id ?? '',
+          LC_GOVERNANCE_POLICY_VERSION: normalized.policy_version ?? '',
+          LC_GOVERNANCE_POLICY_LEASE_ID: governanceLease.lease_id ?? '',
+          LC_GOVERNANCE_POLICY_LEASE_STATE: leaseState,
+          LC_GOVERNANCE_POLICY_LEASE_JSON: JSON.stringify(governanceLease),
+          LC_GOVERNANCE_MCP_CLASSIFICATION_JSON: JSON.stringify(normalizeObject(normalized.mcp_classification)),
+          LC_GOVERNANCE_WORKSPACE_ID: workspaceId ?? '',
+        }
+      : {};
+
+    for (const [serverKey, rawServer] of Object.entries(mcpServers)) {
+      const server = normalizeObject(rawServer);
+      const args = Array.isArray(server.args) ? server.args.map((arg) => this._resolveDirectiveArgPath(String(arg), { chatBridgePath })) : [];
+      const env = Object.fromEntries(Object.entries(normalizeObject(server.env)).map(([k, v]) => [k, String(v ?? '')]));
+      const baseEnv = {};
+      if (serverKey === 'chat' || serverKey === 'publisher' || serverKey === 'platform') {
+        baseEnv.SERVER_URL = this.serverUrl;
+        baseEnv.MACHINE_API_KEY = authToken;
+        baseEnv.AGENT_ID = agentId;
+        baseEnv.WORKSPACE_ID = workspaceId ?? '';
+        baseEnv.WORKSPACE_DIR = workspaceDir;
+      } else if (serverKey === 'workspace-migrate') {
+        baseEnv.SERVER_URL = this.serverUrl;
+        baseEnv.MACHINE_API_KEY = authToken;
+        baseEnv.AGENT_ID = agentId;
+      }
+      mcpServers[serverKey] = {
+        ...server,
+        args,
+        env: {
+          ...env,
+          ...baseEnv,
+          ...(serverKey === 'chat' ? governanceEnv : {}),
+        },
+      };
+    }
+
+    normalized.mcp_servers = mcpServers;
+    return normalized;
+  }
+
+  _cacheDirectiveGovernanceContract(key, normalizedDirective, workspaceId) {
+    const lease = normalizeObject(normalizedDirective?.policy_lease);
+    const cached = {
+      directiveId: normalizedDirective?.directive_id ?? null,
+      spawnBundleId: normalizedDirective?.spawn_bundle_id ?? null,
+      policyVersion: normalizedDirective?.policy_version ?? null,
+      leaseId: lease.lease_id ?? null,
+      workspaceId: workspaceId ?? null,
+      updatedAt: new Date().toISOString(),
+    };
+    this.directiveGovernanceCache.set(key, cached);
+    return cached;
+  }
+
+  _replaceDirectiveValue(value, replacements) {
+    if (typeof value === 'string') return replacePlaceholders(value, replacements);
+    if (Array.isArray(value)) return value.map((item) => this._replaceDirectiveValue(item, replacements));
+    if (!value || typeof value !== 'object') return value;
+    const next = {};
+    for (const [key, itemValue] of Object.entries(value)) {
+      next[key] = this._replaceDirectiveValue(itemValue, replacements);
+    }
+    return next;
+  }
+
+  _resolveDirectiveMcpServers(directive, replacements) {
+    const resolved = this._replaceDirectiveValue(normalizeObject(directive?.mcp_servers), replacements);
+    const mcpServers = {};
+    for (const [serverKey, rawServer] of Object.entries(resolved)) {
+      const server = normalizeObject(rawServer);
+      const command = typeof server.command === 'string' ? server.command.trim() : '';
+      if (!command) continue;
+      mcpServers[serverKey] = {
+        ...server,
+        command,
+        args: Array.isArray(server.args) ? server.args.map((item) => String(item)) : [],
+        env: Object.fromEntries(
+          Object.entries(normalizeObject(server.env)).map(([k, v]) => [k, String(v ?? '')])
+        ),
+      };
+    }
+    return mcpServers;
+  }
+
+  _buildCodexMcpArgs(mcpServers) {
+    const args = [];
+    for (const [serverKey, server] of Object.entries(mcpServers)) {
+      const serverArgs = Array.isArray(server.args) ? server.args.map((item) => String(item)) : [];
+      const envVars = normalizeObject(server.env);
+      const envPairs = Object.entries(envVars).map(([k, v]) => `${k}=${String(v ?? '')}`);
+      const keyExpr = JSON.stringify(serverKey);
+      const commandExpr = JSON.stringify(envPairs.length > 0 ? 'env' : server.command);
+      const argsExpr = JSON.stringify(envPairs.length > 0 ? [...envPairs, server.command, ...serverArgs] : serverArgs);
+      args.push(
+        '-c', `mcp_servers.${keyExpr}.command=${commandExpr}`,
+        '-c', `mcp_servers.${keyExpr}.args=${argsExpr}`,
+        '-c', `mcp_servers.${keyExpr}.enabled=true`,
+      );
+      if (server.required === true) {
+        args.push('-c', `mcp_servers.${keyExpr}.required=true`);
+      }
+    }
+    return args;
+  }
+
+  _createKimiConfigFiles(workspaceDir, { systemPrompt, mcpServers }) {
+    const systemPromptPath = path.join(workspaceDir, KIMI_SYSTEM_PROMPT_FILE);
+    const agentFilePath = path.join(workspaceDir, KIMI_AGENT_FILE);
+    const mcpConfigPath = path.join(workspaceDir, KIMI_MCP_FILE);
+
+    writeFileSync(systemPromptPath, systemPrompt ?? '', 'utf8');
+    writeFileSync(agentFilePath, [
+      'version: 1',
+      'agent:',
+      '  extend: default',
+      `  system_prompt_path: ./${KIMI_SYSTEM_PROMPT_FILE}`,
+      '',
+    ].join('\n'), 'utf8');
+    writeFileSync(mcpConfigPath, JSON.stringify({ mcpServers }), 'utf8');
+
+    return { systemPromptPath, agentFilePath, mcpConfigPath };
+  }
+
+  _buildDirectiveSpawnPlan({
+    directive,
+    runtime,
+    workspaceDir,
+    chatBridgePath,
+    agentId,
+    workspaceId,
+    startupMsg,
+  }) {
+    const systemPrompt = typeof directive?.system_prompt === 'string'
+      ? directive.system_prompt
+      : '';
+    const codexBasePrompt = adaptCodexSystemPrompt(systemPrompt);
+    const codexPrompt = startupMsg
+      ? `${codexBasePrompt}\n\nNew message received:\n\n${this._formatDeliveryText(startupMsg.message)}\n\nRespond as appropriate. Complete all required work before stopping.`
+      : codexBasePrompt;
+
+    const baseReplacements = {
+      '__CHAT_BRIDGE_PATH__': chatBridgePath,
+      '__WORKSPACE_DIR__': workspaceDir,
+      '__SERVER_URL__': this.serverUrl,
+      '__MACHINE_API_KEY__': this.machineApiKey,
+      '__AGENT_ID__': agentId,
+      '__WORKSPACE_ID__': workspaceId ?? '',
+    };
+    const mcpServers = this._resolveDirectiveMcpServers(directive, baseReplacements);
+
+    let kimiFiles = null;
+    if (runtime === 'kimi') {
+      kimiFiles = this._createKimiConfigFiles(workspaceDir, {
+        systemPrompt,
+        mcpServers,
+      });
+    }
+
+    const replacements = {
+      ...baseReplacements,
+      '__SYSTEM_PROMPT__': runtime === 'codex' ? codexPrompt : systemPrompt,
+      '__MCP_CONFIG_JSON__': JSON.stringify({ mcpServers }),
+      '__KIMI_AGENT_FILE__': kimiFiles?.agentFilePath ?? '',
+      '__KIMI_MCP_FILE__': kimiFiles?.mcpConfigPath ?? '',
+    };
+
+    const rawArgs = Array.isArray(directive?.spawn_args) ? directive.spawn_args : [];
+    const args = rawArgs.map((item) => String(this._replaceDirectiveValue(item, replacements)));
+
+    if (runtime === 'claude') {
+      if (!args.includes('--mcp-config')) {
+        args.push('--mcp-config', replacements.__MCP_CONFIG_JSON__);
+      }
+      if (!args.includes('--system-prompt') && systemPrompt.trim()) {
+        args.push('--system-prompt', systemPrompt);
+      }
+    } else if (runtime === 'codex') {
+      if (!args.some((arg) => arg.includes('mcp_servers.')) && Object.keys(mcpServers).length > 0) {
+        args.push(...this._buildCodexMcpArgs(mcpServers));
+      }
+      const hasPromptPlaceholder = rawArgs.some((item) => String(item).includes('__SYSTEM_PROMPT__'));
+      if (!hasPromptPlaceholder && codexPrompt.trim()) {
+        args.push(codexPrompt);
+      }
+    } else if (runtime === 'kimi') {
+      if (!args.includes('--agent-file') && replacements.__KIMI_AGENT_FILE__) {
+        args.push('--agent-file', replacements.__KIMI_AGENT_FILE__);
+      }
+      if (!args.includes('--mcp-config-file') && replacements.__KIMI_MCP_FILE__) {
+        args.push('--mcp-config-file', replacements.__KIMI_MCP_FILE__);
+      }
+    }
+
+    const env = {
+      ...process.env,
+      FORCE_COLOR: '0',
+      NO_COLOR: '1',
+      ...Object.fromEntries(
+        Object.entries(normalizeObject(directive?.env_vars)).map(([k, v]) => [k, String(v ?? '')])
+      ),
+    };
+
+    if (runtime === 'claude') {
+      delete env.CLAUDECODE;
+    }
+
+    const sessionArgIndex = args.indexOf('--session');
+    const kimiSessionId = runtime === 'kimi' && sessionArgIndex !== -1 ? args[sessionArgIndex + 1] ?? null : null;
+
+    return {
+      command: runtime,
+      args,
+      env,
+      kimiSessionId,
+    };
+  }
+
+  async _fetchSpawnDirective({
+    agentId,
+    workspaceId,
+    runtime,
+    workspaceDir,
+    chatBridgePath,
+    config,
+    triggerType = 'resume',
+  }) {
+    const res = await fetch(`${this.serverUrl}/governance/spawn-directive`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Authorization': `Bearer ${this.machineApiKey}`,
+      },
+      body: JSON.stringify({
+        agent_id: agentId,
+        workspace_id: workspaceId ?? null,
+        trigger: {
+          type: triggerType,
+          context: { source: 'daemon-agent-manager' },
+        },
+        runtime_context: {
+          cli_type: runtime,
+          session_id: config?.sessionId ?? null,
+          workspace_dir: workspaceDir,
+          chat_bridge_path: chatBridgePath,
+        },
+        agent_profile: {
+          name: config?.name ?? null,
+          display_name: config?.displayName ?? null,
+          description: config?.description ?? null,
+          role_prompt: config?.rolePrompt ?? null,
+          feishu_bot_name: config?.feishuBotName ?? null,
+        },
+      }),
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`spawn_directive_failed:${res.status}:${text.slice(0, 300)}`);
+    }
+    const directive = await res.json();
+    if (!directive || typeof directive !== 'object') {
+      throw new Error('spawn_directive_invalid_response');
+    }
+    return directive;
+  }
+
+  _clearDirectiveRefresh(key) {
+    const timer = this.directiveRefreshTimers.get(key);
+    if (timer) clearTimeout(timer);
+    this.directiveRefreshTimers.delete(key);
+  }
+
+  _scheduleDirectiveRefresh(key, context, directive) {
+    this._clearDirectiveRefresh(key);
+    if (!directive || typeof directive !== 'object') return;
+
+    let ttlMs = Number(directive.lease_ttl_ms ?? NaN);
+    if (!Number.isFinite(ttlMs) || ttlMs <= 0) {
+      const validUntilMs = Date.parse(directive?.policy_lease?.valid_until ?? '');
+      if (Number.isFinite(validUntilMs)) {
+        ttlMs = validUntilMs - Date.now();
+      }
+    }
+    if (!Number.isFinite(ttlMs) || ttlMs <= 0) return;
+
+    let refreshInMs = Math.max(250, ttlMs - 2000);
+    if (ttlMs <= 250) {
+      // Keep refresh strictly before expiry even for short leases.
+      refreshInMs = ttlMs > 1
+        ? Math.max(1, Math.min(ttlMs - 1, Math.floor(ttlMs * 0.5)))
+        : 1;
+    }
+    const timer = setTimeout(async () => {
+      if (!this.agents.has(key)) return;
+      try {
+        const nextDirective = await this._fetchSpawnDirective({
+          ...context,
+          triggerType: 'lease_refresh',
+        });
+        const agent = this.agents.get(key);
+        if (!agent) return;
+        agent.directive = nextDirective;
+        this._scheduleDirectiveRefresh(key, context, nextDirective);
+      } catch (err) {
+        console.log(`[AgentManager] Spawn directive refresh failed for ${context.agentId}: ${err.message}`);
+        // Retry later; fail-safe for transient network failures.
+        this._scheduleDirectiveRefresh(key, context, {
+          ...directive,
+          lease_ttl_ms: 5000,
+        });
+      }
+    }, refreshInMs);
+    this.directiveRefreshTimers.set(key, timer);
+  }
+
+  async _startAgent({ agentId, workspaceId, workspaceName, config }, connection) {
+    const key = this._key(agentId, workspaceId);
     if (this.agents.has(key) || this.starting.has(key)) {
-      console.log(`[AgentManager] Agent ${config?.displayName ?? agentId} in team ${teamName ?? teamId} already registered`);
+      console.log(`[AgentManager] Agent ${config?.displayName ?? agentId} in workspace ${workspaceName ?? workspaceId} already registered`);
       return;
     }
     this.starting.add(key);
 
-    const runtime = config.runtime ?? 'claude';
-    const teamWorkspaceDir = this._teamWorkspaceDir(teamId);
-    const workspaceDir = this._workspaceDir(agentId, teamId);
+    const requestedRuntime = String(config.runtime ?? 'claude').trim().toLowerCase() || 'claude';
+    this._workspaceRootDir(workspaceId);
+    const workspaceDir = this._workspaceDir(agentId, workspaceId);
     const chatBridgePath = new URL('./chat-bridge.js', import.meta.url).pathname;
-    const startupMsg = runtime === 'codex' ? this._takePendingMessage(key) : null;
+    const failStart = (reason) => {
+      this._clearDirectiveRefresh(key);
+      this.starting.delete(key);
+      connection.send({ type: 'agent:status', agentId, workspaceId, status: 'inactive' });
+      connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'offline', detail: reason ?? '', entries: [] });
+    };
 
-    // Fetch skills for system prompt + MCP derivation (non-blocking on failure)
+    let directive = null;
+    try {
+      directive = await this._fetchSpawnDirective({
+        agentId,
+        workspaceId,
+        runtime: requestedRuntime,
+        workspaceDir,
+        chatBridgePath,
+        config,
+      });
+      console.log(`[AgentManager] Spawn directive loaded for ${config.displayName ?? agentId}: ${directive.directive_id ?? 'n/a'} cli=${directive.cli_type ?? requestedRuntime}`);
+      this._scheduleDirectiveRefresh(key, {
+        agentId,
+        workspaceId,
+        runtime: requestedRuntime,
+        workspaceDir,
+        chatBridgePath,
+        config,
+      }, directive);
+    } catch (err) {
+      console.log(`[AgentManager] Spawn directive fetch failed for ${agentId} (fail-closed): ${err.message}`);
+      failStart('spawn_directive_failed');
+      return;
+    }
+
+    const runtime = String(directive?.cli_type ?? requestedRuntime).trim().toLowerCase() || requestedRuntime;
+    if (!['claude', 'codex', 'kimi'].includes(runtime)) {
+      console.log(`[AgentManager] Unsupported runtime in directive for ${agentId}: ${runtime}`);
+      failStart('spawn_directive_invalid_runtime');
+      return;
+    }
+    if (!Array.isArray(directive?.spawn_args)) {
+      console.log(`[AgentManager] Invalid spawn args in directive for ${agentId}`);
+      failStart('spawn_directive_invalid_args');
+      return;
+    }
+
+    const { startupMsg } = this._prepareStartupMessage(key, runtime);
+
+    // Keep .skills materialization for runtime compatibility, but no longer use skills to build prompt/env/mcp.
     let skills = [];
     try {
       const res = await fetch(`${this.serverUrl}/internal/agent/${agentId}/skills`, {
         headers: { 'Authorization': `Bearer ${this.machineApiKey}` },
       });
       if (res.ok) skills = await res.json();
-      const mcpSkills = skills.filter(s => s.mcpConfig);
-      console.log(`[AgentManager] Skills loaded for ${config.displayName ?? agentId}: ${skills.length} total, ${mcpSkills.length} with MCP (${mcpSkills.map(s => s.name).join(', ') || 'none'})`);
+      console.log(`[AgentManager] Skills loaded for ${config.displayName ?? agentId}: ${skills.length}`);
     } catch (err) {
       console.log(`[AgentManager] Skills fetch failed for ${agentId} (non-fatal): ${err.message}`);
     }
+    this._materializeSkills(workspaceDir, skills);
 
-    // Fetch credential grants for this agent (non-blocking on failure)
-    let credentialGrants = [];
+    const requiredCredentials = Array.isArray(directive?.required_credentials)
+      ? directive.required_credentials.filter(Boolean)
+      : [];
+    let credentialEnvVars = {};
     try {
-      const res = await fetch(`${this.serverUrl}/internal/agent/${agentId}/credential-grants`, {
-        headers: { 'Authorization': `Bearer ${this.machineApiKey}` },
+      const res = await fetch(`${this.serverUrl}/governance/credential-broker`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          'Authorization': `Bearer ${this.machineApiKey}`,
+        },
+        body: JSON.stringify({
+          agent_id: agentId,
+          workspace_id: workspaceId ?? null,
+          required_credentials: requiredCredentials,
+          bundle_id: directive?.spawn_bundle_id ?? null,
+        }),
       });
-      if (res.ok) credentialGrants = await res.json();
-      console.log(`[AgentManager] Credential grants for ${config.displayName ?? agentId}: ${credentialGrants.map(g => `${g.platform}(${Object.keys(g.envVars ?? {}).join(',')})`).join(', ') || 'none'}`);
+      if (res.ok) {
+        const payload = await res.json();
+        credentialEnvVars = (payload?.env_vars && typeof payload.env_vars === 'object')
+          ? payload.env_vars
+          : {};
+        console.log(`[AgentManager] Brokered credentials for ${config.displayName ?? agentId}: ${Object.keys(credentialEnvVars).join(', ') || 'none'}`);
+      } else {
+        const text = await res.text();
+        if (requiredCredentials.length > 0) {
+          throw new Error(`credential_broker_denied:${res.status}:${text.slice(0, 200)}`);
+        }
+        console.log(`[AgentManager] Credential broker denied for ${agentId} (non-fatal): ${res.status} ${text.slice(0, 200)}`);
+      }
     } catch (err) {
-      console.log(`[AgentManager] Credential grants fetch failed for ${agentId} (non-fatal): ${err.message}`);
+      if (requiredCredentials.length > 0) {
+        console.log(`[AgentManager] Credential broker failed for ${agentId} (fail-closed): ${err.message}`);
+        failStart('credential_broker_failed');
+        return;
+      }
+      console.log(`[AgentManager] Credential broker failed for ${agentId} (non-fatal): ${err.message}`);
     }
 
-    // Materialize bound skills into .skills/ directory
-    this._materializeSkills(workspaceDir, skills);
+    const directiveEnvVars = normalizeObject(directive?.env_vars);
+    directive.env_vars = {
+      ...directiveEnvVars,
+      ...credentialEnvVars,
+    };
 
-    let proc;
+    const runtimeConfig = {
+      ...config,
+      authToken: this.machineApiKey,
+      systemPrompt: typeof directive?.system_prompt === 'string' ? directive.system_prompt : '',
+      envVars: normalizeObject(directive?.env_vars),
+    };
 
-    if (runtime === 'kimi') {
-      // ── Kimi CLI ──────────────────────────────────────────────────────────
-      const kimiSpawn = buildKimiSpawn({
-        config, agentId, teamId, workspaceDir, chatBridgePath,
-        serverUrl: this.serverUrl, machineApiKey: this.machineApiKey, skills,
-        credentialGrants,
+    let spawnPlan;
+    try {
+      spawnPlan = this._buildDirectiveSpawnPlan({
+        directive,
+        runtime,
+        workspaceDir,
+        chatBridgePath,
+        agentId,
+        workspaceId,
+        startupMsg,
       });
+    } catch (err) {
+      console.log(`[AgentManager] Failed to build spawn plan for ${agentId}: ${err.message}`);
+      failStart('spawn_plan_invalid');
+      return;
+    }
 
-      console.log(`[AgentManager] Spawning kimi for ${config.displayName ?? agentId} team=${teamName ?? teamId ?? 'none'} (session=${kimiSpawn.sessionId})`);
+    console.log(`[AgentManager] Spawning ${runtime} for ${config.displayName ?? agentId} workspace=${workspaceName ?? workspaceId ?? 'none'} directive=${directive.directive_id ?? 'n/a'}`);
+    const stdio = runtime === 'codex'
+      ? ['ignore', 'pipe', 'pipe']
+      : ['pipe', 'pipe', 'pipe'];
+    const proc = spawn(spawnPlan.command, spawnPlan.args, {
+      cwd: workspaceDir,
+      env: spawnPlan.env,
+      stdio,
+    });
+    let spawnErrorReported = false;
 
-      proc = spawn('kimi', kimiSpawn.args, {
-        cwd: workspaceDir,
-        env: kimiSpawn.env,
-        stdio: ['pipe', 'pipe', 'pipe'],
-      });
+    const reportSpawnFailure = (detail) => {
+      if (spawnErrorReported) return;
+      spawnErrorReported = true;
+      this._clearDirectiveRefresh(key);
+      this.starting.delete(key);
+      this.agents.delete(key);
+      connection.send({ type: 'agent:status', agentId, workspaceId, status: 'inactive' });
+      connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'offline', detail: detail ?? 'spawn_failed', entries: [] });
+    };
 
-      // Send initialize + prompt via stdin
-      const initMsgs = buildKimiInitMessages(kimiSpawn);
-      for (const msg of initMsgs) {
-        proc.stdin.write(msg + '\n');
-      }
+    proc.once('error', (err) => {
+      const detail = err?.code === 'ENOENT'
+        ? runtimeMissingDetail(runtime)
+        : 'spawn_failed';
+      console.log(`[AgentManager] Spawn process error for ${agentId} (${runtime}): ${err?.message ?? 'unknown error'}`);
+      reportSpawnFailure(detail);
+    });
 
-      // Track Kimi-specific state for parsing
-      const kimiState = { sessionId: kimiSpawn.sessionId, sessionAnnounced: false };
+    if (runtime === 'kimi') {
+      const sessionId = spawnPlan.kimiSessionId ?? null;
+      const kimiState = { sessionId, sessionAnnounced: false };
 
       this.agents.set(key, {
-        config, teamId, agentId, sessionId: kimiSpawn.sessionId, proc,
-        runtime: 'kimi', kimiState, kimiIdle: false,
+        config: runtimeConfig,
+        workspaceId,
+        agentId,
+        sessionId,
+        proc,
+        runtime: 'kimi',
+        kimiState,
+        kimiIdle: false,
+        directive,
+        requiredCredentials,
+        stopCause: null,
       });
       this.starting.delete(key);
 
+      // Kimi wire protocol requires initialize before prompt/steer frames.
+      const initMessages = [
+        JSON.stringify({
+          jsonrpc: '2.0',
+          id: `${Date.now()}-init`,
+          method: 'initialize',
+          params: {
+            protocol_version: '1.3',
+            client: { name: 'lightcone-daemon', version: '1.0.0' },
+            capabilities: { supports_question: false, supports_plan_mode: false },
+          },
+        }),
+        JSON.stringify({
+          jsonrpc: '2.0',
+          id: `${Date.now()}-prompt`,
+          method: 'prompt',
+          params: {
+            user_input: 'Your system prompt contains your standing instructions. Follow it now and begin listening for messages.',
+          },
+        }),
+      ];
+      for (const msg of initMessages) {
+        proc.stdin.write(msg + '\n');
+      }
+
       let buffer = '';
       proc.stdout.on('data', (chunk) => {
         buffer += chunk.toString();
@@ -172,38 +725,20 @@ export class AgentManager {
         buffer = lines.pop();
         for (const line of lines) {
           if (!line.trim()) continue;
-          this._parseKimiLine(key, agentId, teamId, line, connection);
+          this._parseKimiLine(key, agentId, workspaceId, line, connection);
         }
       });
     } else if (runtime === 'codex') {
-      const startupPrompt = startupMsg
-        ? `${buildCodexSystemPrompt(config, agentId)}\n\nNew message received:\n\n${this._formatDeliveryText(startupMsg.message)}\n\nRespond as appropriate. Complete all required work before stopping.`
-        : buildCodexSystemPrompt(config, agentId);
-
-      const codexSpawn = buildCodexSpawn({
-        config,
-        agentId,
-        teamId,
-        workspaceDir,
-        chatBridgePath,
-        serverUrl: this.serverUrl,
-        machineApiKey: this.machineApiKey,
-        prompt: startupPrompt,
-        skills,
-        credentialGrants,
-      });
-
-      console.log(`[AgentManager] Spawning codex for ${config.displayName ?? agentId} team=${teamName ?? teamId ?? 'none'} (session=${config.sessionId ?? 'new'})`);
-
-      proc = spawn('codex', codexSpawn.args, {
-        cwd: workspaceDir,
-        env: codexSpawn.env,
-        stdio: ['ignore', 'pipe', 'pipe'],
-      });
-
       this.agents.set(key, {
-        config, teamId, agentId, sessionId: config.sessionId ?? null, proc,
+        config: runtimeConfig,
+        workspaceId,
+        agentId,
+        sessionId: config.sessionId ?? null,
+        proc,
         runtime: 'codex',
+        directive,
+        requiredCredentials,
+        stopCause: null,
       });
       this.starting.delete(key);
 
@@ -214,80 +749,23 @@ export class AgentManager {
         buffer = lines.pop();
         for (const line of lines) {
           if (!line.trim()) continue;
-          this._parseCodexLine(key, agentId, teamId, line, connection);
+          this._parseCodexLine(key, agentId, workspaceId, line, connection);
         }
       });
     } else {
-      // ── Claude CLI (default) ──────────────────────────────────────────────
-      const mcpServers = {
-        chat: {
-          command: 'node',
-          args: [chatBridgePath],
-          env: {
-            SERVER_URL: this.serverUrl,
-            MACHINE_API_KEY: config.authToken,
-            AGENT_ID: agentId,
-            TEAM_ID: teamId ?? '',
-            WORKSPACE_DIR: workspaceDir,
-          },
-        },
-      };
-
-      Object.assign(mcpServers, buildSkillMcpServers({
-        skills,
-        credentialGrants,
-        config,
+      this.agents.set(key, {
+        config: runtimeConfig,
+        workspaceId,
         agentId,
-        workspaceDir,
-        serverUrl: this.serverUrl,
-        authToken: config.authToken,
-      }));
-
-      const mcpConfig = { mcpServers };
-      console.log(`[AgentManager] MCP servers for ${config.displayName ?? agentId}: ${Object.keys(mcpServers).join(', ')}`);
-      for (const [name, mc] of Object.entries(mcpServers)) {
-        console.log(`[AgentManager]   mcp:${name} → ${mc.command} ${(mc.args ?? []).join(' ')}`);
-      }
-
-      const args = [
-        '--print',
-        '--allow-dangerously-skip-permissions',
-        '--dangerously-skip-permissions',
-        '--verbose',
-        '--output-format', 'stream-json',
-        '--input-format', 'stream-json',
-        '--mcp-config', JSON.stringify(mcpConfig),
-        '--system-prompt', buildSystemPrompt(config, agentId, skills),
-        '--disallowed-tools', 'EnterPlanMode,ExitPlanMode',
-      ];
-
-      if (config.sessionId) {
-        // Only resume if the session file exists locally
-        const projectSlug = workspaceDir.replace(/[\/\.]/g, '-');
-        const sessionFile = path.join(homedir(), '.claude', 'projects', projectSlug, `${config.sessionId}.jsonl`);
-        try {
-          statSync(sessionFile);
-          args.push('--resume', config.sessionId);
-        } catch {
-          console.log(`[AgentManager] Session ${config.sessionId} not found locally, starting fresh`);
-        }
-      }
-
-      const spawnEnv = { ...process.env, FORCE_COLOR: '0', ...(config.envVars ?? {}) };
-      delete spawnEnv.CLAUDECODE;
-
-      console.log(`[AgentManager] Spawning claude for ${config.displayName ?? agentId} team=${teamName ?? teamId ?? 'none'} (session=${config.sessionId ?? 'new'})`);
-
-      proc = spawn('claude', args, {
-        cwd: workspaceDir,
-        env: spawnEnv,
-        stdio: ['pipe', 'pipe', 'pipe'],
+        sessionId: config.sessionId ?? null,
+        proc,
+        runtime: 'claude',
+        directive,
+        requiredCredentials,
+        stopCause: null,
       });
-
-      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
       let buffer = '';
       proc.stdout.on('data', (chunk) => {
         buffer += chunk.toString();
@@ -295,7 +773,7 @@ export class AgentManager {
         buffer = lines.pop();
         for (const line of lines) {
           if (!line.trim()) continue;
-          this._parseLine(key, agentId, teamId, line, connection);
+          this._parseLine(key, agentId, workspaceId, line, connection);
         }
       });
     }
@@ -305,14 +783,16 @@ export class AgentManager {
       if (text) console.error(`[AgentManager][${config.displayName ?? agentId}] stderr: ${text.slice(0, 500)}`);
     });
 
-    proc.on('exit', (code) => {
+    proc.on('exit', (code, signal) => {
+      if (spawnErrorReported) return;
       const agent = this.agents.get(key);
-      console.log(`[AgentManager] Agent ${config.displayName ?? agentId} team=${teamName ?? teamId ?? 'none'} exited (code=${code})`);
+      console.log(`[AgentManager] Agent ${config.displayName ?? agentId} workspace=${workspaceName ?? workspaceId ?? 'none'} exited (code=${code}, signal=${signal ?? 'none'})`);
+      this._clearDirectiveRefresh(key);
       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, teamId, config: restartConfig }, connection);
+        this._startAgent({ agentId, workspaceId, config: restartConfig }, connection);
         return;
       }
 
@@ -320,14 +800,20 @@ 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} team=${teamId} without session (session may not exist locally)`);
+        console.log(`[AgentManager] Retrying ${agentId} workspace=${workspaceId} without session (session may not exist locally)`);
         const retryConfig = { ...config, sessionId: null };
-        this._startAgent({ agentId, teamId, config: retryConfig }, connection);
+        this._startAgent({ agentId, workspaceId, config: retryConfig }, connection);
         return;
       }
 
-      connection.send({ type: 'agent:status', agentId, teamId, status: 'inactive' });
-      connection.send({ type: 'agent:activity', agentId, teamId, activity: 'offline', detail: '', entries: [] });
+      const offlineDetail = resolveExitOfflineDetail({
+        code,
+        signal,
+        stopCause: agent?.stopCause ?? null,
+      });
+
+      connection.send({ type: 'agent:status', agentId, workspaceId, status: 'inactive' });
+      connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'offline', detail: offlineDetail, entries: [] });
     });
 
     // Send startup prompt
@@ -337,9 +823,9 @@ 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.');
     }
 
-    console.log(`[AgentManager] Agent ${config.displayName ?? agentId} is now active (team=${teamName ?? teamId ?? 'none'})`);
-    connection.send({ type: 'agent:status', agentId, teamId, status: 'active' });
-    connection.send({ type: 'agent:activity', agentId, teamId, activity: 'online', detail: '', entries: [] });
+    console.log(`[AgentManager] Agent ${config.displayName ?? agentId} is now active (workspace=${workspaceName ?? workspaceId ?? 'none'})`);
+    connection.send({ type: 'agent:status', agentId, workspaceId, status: 'active' });
+    connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'online', detail: '', entries: [] });
 
     // Flush any messages that arrived while the agent was starting
     this._flushPending(key, connection);
@@ -362,34 +848,122 @@ export class AgentManager {
     return stopSession(platform);
   }
 
-  _stopAgent(agentId, teamId, connection) {
-    const key = this._key(agentId, teamId);
+  _handlePolicyInvalidate(msg, connection) {
+    const leaseIds = Array.isArray(msg.lease_ids) ? msg.lease_ids.filter(Boolean) : [];
+    const reason = msg.reason ?? 'policy_updated';
+    const newPolicyHash = msg.new_policy_hash ?? null;
+    const invalidated = markInvalidatedLeases(leaseIds, { reason, newPolicyHash });
+    const invalidatedSet = new Set(leaseIds);
+    const normalizedReason = String(reason).trim().toLowerCase();
+    const forceFreshSession = normalizedReason === 'policy_major_changed'
+      || normalizedReason === 'policy_major_change';
+
+    console.log(`[AgentManager] Received policy_invalidate: reason=${reason} leases=${invalidated}`);
+    connection.send({
+      type: 'policy_invalidate:ack',
+      lease_ids: leaseIds,
+      reason,
+      received_at: new Date().toISOString(),
+    });
+
+    let stopped = 0;
+    for (const [agentKey, agent] of this.agents.entries()) {
+      const leaseId = agent.directive?.policy_lease?.lease_id ?? null;
+      // Fail-closed: when no lease_id is present on agent state, treat it as affected.
+      const shouldStop = invalidatedSet.size === 0
+        || !leaseId
+        || invalidatedSet.has(leaseId);
+      if (!shouldStop) continue;
+
+      let workspaceId = agent.workspaceId ?? null;
+      let agentId = agent.agentId ?? null;
+      if (!agentId) {
+        const splitAt = agentKey.indexOf(':');
+        if (splitAt === -1) {
+          agentId = agentKey;
+        } else {
+          workspaceId = workspaceId ?? (agentKey.slice(0, splitAt) || null);
+          agentId = agentKey.slice(splitAt + 1);
+        }
+      }
+
+      if (forceFreshSession && agent.sessionId && agentId) {
+        agent.sessionId = null;
+        connection.send({ type: 'agent:session', agentId, workspaceId, sessionId: null });
+      }
+
+      this._clearDirectiveRefresh(agentKey);
+      agent.proc?.kill();
+      stopped += 1;
+    }
+
+    if (stopped > 0) {
+      console.log(`[AgentManager] policy_invalidate stopped ${stopped} active agent process(es)`);
+    }
+  }
+
+  _handleCredentialRevoked(msg, connection) {
+    const credentialIds = Array.isArray(msg.credential_ids) ? msg.credential_ids.filter(Boolean) : [];
+    const reason = msg.reason ?? 'credential_revoked';
+    console.log(`[AgentManager] Received credential_revoked: reason=${reason} credential_ids=${credentialIds.join(',') || 'none'}`);
+    connection.send({
+      type: 'credential_revoked:ack',
+      credential_ids: credentialIds,
+      reason,
+      received_at: new Date().toISOString(),
+    });
+
+    const revoked = new Set(credentialIds);
+    let stopped = 0;
+    for (const [agentKey, agent] of this.agents.entries()) {
+      const required = Array.isArray(agent.requiredCredentials)
+        ? agent.requiredCredentials.filter(Boolean)
+        : [];
+      // Fail-closed: if directive omitted required credential IDs, assume this agent may be affected.
+      const shouldStop = revoked.size === 0
+        || required.length === 0
+        || required.some((id) => revoked.has(id));
+      if (!shouldStop) continue;
+      this._clearDirectiveRefresh(agentKey);
+      agent.stopCause = 'credential_revoked';
+      agent.proc?.kill();
+      stopped += 1;
+    }
+    if (stopped > 0) {
+      console.log(`[AgentManager] credential_revoked stopped ${stopped} active agent process(es)`);
+    }
+  }
+
+  _stopAgent(agentId, workspaceId, connection) {
+    const key = this._key(agentId, workspaceId);
     const agent = this.agents.get(key);
     if (!agent) return;
-    console.log(`[AgentManager] Stopping agent ${agentId} team=${teamId ?? 'none'}`);
+    console.log(`[AgentManager] Stopping agent ${agentId} workspace=${workspaceId ?? 'none'}`);
+    this._clearDirectiveRefresh(key);
+    agent.stopCause = 'manual_stop';
     agent.proc?.kill();
     // exit handler will report status
   }
 
   _deliverMessage(msg, connection) {
-    const { agentId, teamId, seq, message } = msg;
-    const key = this._key(agentId, teamId);
-    connection.send({ type: 'agent:deliver:ack', agentId, teamId, seq });
+    const { agentId, workspaceId, seq, message } = msg;
+    const key = this._key(agentId, workspaceId);
+    connection.send({ type: 'agent:deliver:ack', agentId, workspaceId, 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.slice(0,8)} team=${message.team_name ?? teamId} not running, requesting start for seq=${seq}`);
+      console.log(`[AgentManager] Agent ${agentId.slice(0,8)} workspace=${message.workspace_name ?? workspaceId} 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, teamId });
+      connection.send({ type: 'agent:request_start', agentId, workspaceId });
       return;
     }
 
     if (this.starting.has(key)) {
       // Spawn in progress — queue the message for delivery after start
-      console.log(`[AgentManager] Agent ${agentId.slice(0,8)} team=${message.team_name ?? teamId} still starting, queuing seq=${seq}`);
+      console.log(`[AgentManager] Agent ${agentId.slice(0,8)} workspace=${message.workspace_name ?? workspaceId} still starting, queuing seq=${seq}`);
       if (!this._pendingMessages) this._pendingMessages = new Map();
       const pending = this._pendingMessages.get(key) ?? [];
       pending.push(msg);
@@ -399,7 +973,7 @@ export class AgentManager {
 
     const text = this._formatDeliveryText(message);
     const agent = this.agents.get(key);
-    console.log(`[AgentManager] Delivering seq=${seq} to agent ${agent?.config?.displayName ?? agentId.slice(0,8)} team=${message.team_name ?? teamId}`);
+    console.log(`[AgentManager] Delivering seq=${seq} to agent ${agent?.config?.displayName ?? agentId.slice(0,8)} workspace=${message.workspace_name ?? workspaceId}`);
     if (agent?.runtime === 'codex') {
       if (!this._pendingMessages) this._pendingMessages = new Map();
       const pending = this._pendingMessages.get(key) ?? [];
@@ -417,10 +991,10 @@ export class AgentManager {
     if (!pending || pending.length === 0) return;
     this._pendingMessages.delete(key);
     for (const msg of pending) {
-      const { agentId, teamId, seq, message } = msg;
+      const { agentId, workspaceId, seq, message } = msg;
       const text = this._formatDeliveryText(message);
       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}`);
+      console.log(`[AgentManager] Flushing queued seq=${seq} to agent ${agent?.config?.displayName ?? agentId.slice(0,8)} workspace=${message.workspace_name ?? workspaceId}`);
       this._write(key, text);
     }
   }
@@ -453,7 +1027,7 @@ export class AgentManager {
     }
   }
 
-  _parseKimiLine(key, agentId, teamId, line, connection) {
+  _parseKimiLine(key, agentId, workspaceId, line, connection) {
     const agent = this.agents.get(key);
     if (!agent) return;
     const events = parseKimiLine(line, agent.kimiState);
@@ -462,18 +1036,18 @@ export class AgentManager {
         case 'session_init':
           if (agent.sessionId !== evt.sessionId) {
             agent.sessionId = evt.sessionId;
-            connection.send({ type: 'agent:session', agentId, teamId, sessionId: evt.sessionId });
+            connection.send({ type: 'agent:session', agentId, workspaceId, sessionId: evt.sessionId });
           }
           break;
         case 'thinking':
-          connection.send({ type: 'agent:activity', agentId, teamId, activity: 'thinking', detail: '', entries: [] });
+          connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'thinking', detail: '', entries: [] });
           break;
         case 'tool_call':
-          connection.send({ type: 'agent:activity', agentId, teamId, activity: 'working', detail: evt.name, entries: [] });
+          connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'working', detail: evt.name, entries: [] });
           break;
         case 'turn_end':
           agent.kimiIdle = true;
-          connection.send({ type: 'agent:activity', agentId, teamId, activity: 'online', detail: '', entries: [] });
+          connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'online', detail: '', entries: [] });
           break;
         case 'error':
           console.error(`[AgentManager][kimi][${agentId}] Error: ${evt.message}`);
@@ -482,7 +1056,7 @@ export class AgentManager {
     }
   }
 
-  _parseCodexLine(key, agentId, teamId, line, connection) {
+  _parseCodexLine(key, agentId, workspaceId, line, connection) {
     const agent = this.agents.get(key);
     if (!agent) return;
     const events = parseCodexLine(line);
@@ -491,17 +1065,17 @@ export class AgentManager {
         case 'session_init':
           if (agent.sessionId !== evt.sessionId) {
             agent.sessionId = evt.sessionId;
-            connection.send({ type: 'agent:session', agentId, teamId, sessionId: evt.sessionId });
+            connection.send({ type: 'agent:session', agentId, workspaceId, sessionId: evt.sessionId });
           }
           break;
         case 'thinking':
-          connection.send({ type: 'agent:activity', agentId, teamId, activity: 'thinking', detail: '', entries: [] });
+          connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'thinking', detail: '', entries: [] });
           break;
         case 'tool_call':
-          connection.send({ type: 'agent:activity', agentId, teamId, activity: 'working', detail: evt.name, entries: [] });
+          connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'working', detail: evt.name, entries: [] });
           break;
         case 'turn_end':
-          connection.send({ type: 'agent:activity', agentId, teamId, activity: 'online', detail: '', entries: [] });
+          connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'online', detail: '', entries: [] });
           break;
         case 'error':
           console.error(`[AgentManager][codex][${agentId}] Error: ${evt.message}`);
@@ -510,7 +1084,7 @@ export class AgentManager {
     }
   }
 
-  _parseLine(key, agentId, teamId, line, connection) {
+  _parseLine(key, agentId, workspaceId, line, connection) {
     let event;
     try { event = JSON.parse(line); }
     catch { return; }
@@ -520,7 +1094,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, teamId, sessionId: event.session_id });
+        connection.send({ type: 'agent:session', agentId, workspaceId, sessionId: event.session_id });
       }
     }
 
@@ -535,11 +1109,11 @@ export class AgentManager {
           console.log(`[AgentManager][${displayName}] <text> ${block.text?.slice(0, 500)}`);
         } else if (block.type === 'tool_use') {
           console.log(`[AgentManager][${displayName}] <tool_use> ${block.name} params=${JSON.stringify(block.input ?? {}).slice(0, 500)}`);
-          connection.send({ type: 'agent:activity', agentId, teamId, activity: 'working', detail: block.name, entries: [] });
+          connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'working', detail: block.name, entries: [] });
         }
       }
       if (!content.some(c => c.type === 'tool_use')) {
-        connection.send({ type: 'agent:activity', agentId, teamId, activity: 'thinking', detail: '', entries: [] });
+        connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'thinking', detail: '', entries: [] });
       }
     } else if (event.type === 'tool') {
       const content = event.content;
@@ -558,7 +1132,7 @@ export class AgentManager {
       }
     } else if (event.type === 'result') {
       console.log(`[AgentManager][${displayName}] turn done (stop_reason=${event.stop_reason ?? '?'})`);
-      connection.send({ type: 'agent:activity', agentId, teamId, activity: 'online', detail: '', entries: [] });
+      connection.send({ type: 'agent:activity', agentId, workspaceId, activity: 'online', detail: '', entries: [] });
     }
   }
 }