@yeaft/webchat-agent 0.1.225 → 0.1.226

package/conductor/session.js

@@ -1,19 +1,16 @@
 /**
- * Conductor — Session 核心
+ * Conductor — Session Core (V5 Singleton)
  *
- * 管理 Conductor session 的完整生命周期。
- * 与 V1 Crew 的关键区别：
- * - 不绑定固定工作路径，workDir 可动态切换
- * - 不定义固定角色列表，task 创建时由 orchestrator 决定
- * - session 级元数据存在 ~/.claude/conductor/<sessionId>/
+ * Each Agent has exactly one Conductor (1:1 binding).
+ * No multi-session Map — just a single conductor instance.
+ *
+ * Conductor has no workDir; tasks bind to workDir.
  */
-import { randomUUID } from 'crypto';
 import ctx from '../context.js';
 import {
-  loadConductorIndex, upsertConductorIndex,
-  loadSessionMeta, saveSessionMeta, loadSessionMessages,
-  getMaxShardIndex, getSessionDataDir, initSessionDataDir,
-  cleanupMessageShards
+  ensureConductorHome, loadConductorMeta, saveConductorMeta,
+  loadConductorMessages, loadState, getMaxShardIndex,
+  getConductorHome, cleanupMessageShards
 } from './persistence.js';
 import {
   sendConductorMessage, sendConductorOutput, sendStatusUpdate, recordUserMessage
@@ -21,335 +18,191 @@ import {
 import { createConductorClaude, sendToConductor, stopConductorClaude } from './conductor-claude.js';
 
 // =====================================================================
-// Data Structures
+// Singleton Conductor Instance
 // =====================================================================
 
-/** @type {Map<string, ConductorSession>} */
-export const conductorSessions = new Map();
-
-// =====================================================================
-// Session Lifecycle
-// =====================================================================
+/** @type {Conductor|null} */
+let conductor = null;
 
 /**
- * 创建 Conductor Session
+ * Get the current Conductor instance (or null if not initialized)
  */
-export async function createConductorSession(msg) {
-  const {
-    sessionId = randomUUID(),
-    name = '',
-    workDir = null,
-    scenarioId = null,
-    userId,
-    username
-  } = msg;
-
-  const session = {
-    id: sessionId,
-    name: name || 'Conductor',
-    workDir,
-    scenarioId,
-    status: 'running',
-    tasks: new Map(),
-    conductorState: null,
-    costUsd: 0,
-    totalInputTokens: 0,
-    totalOutputTokens: 0,
-    activeClaudes: 0,
-    uiMessages: [],
-    userId,
-    username,
-    agentId: ctx.CONFIG?.agentName || null,
-    createdAt: Date.now(),
-    _rotating: false,
-    _conductorSemRelease: null
-  };
-
-  conductorSessions.set(sessionId, session);
-
-  // 初始化数据目录
-  await initSessionDataDir(sessionId);
-
-  // 通知前端
-  sendConductorMessage({
-    type: 'conductor_session_created',
-    sessionId,
-    name: session.name,
-    workDir: session.workDir,
-    scenarioId: session.scenarioId,
-    userId,
-    username
-  });
-
-  sendStatusUpdate(session);
-
-  // 注册到全局 index
-  await upsertConductorIndex(session);
-  await saveSessionMeta(session);
-
-  // 启动 Conductor Claude
-  try {
-    await createConductorClaude(session);
-    console.log(`[Conductor] Session ${sessionId} created, Claude ready`);
-  } catch (e) {
-    console.error('[Conductor] Failed to start Claude:', e.message);
-    sendConductorOutput(session, 'system', {
-      message: { role: 'assistant', content: `Conductor 启动失败: ${e.message}` }
-    });
-  }
-
-  return session;
+export function getConductor() {
+  return conductor;
 }
 
-/**
- * 列出所有 conductor sessions
- */
-export async function handleListConductorSessions(msg) {
-  const { requestId, _requestClientId } = msg;
-  const index = await loadConductorIndex();
-
-  const agentId = ctx.CONFIG?.agentName || null;
-  const filtered = agentId
-    ? index.filter(e => !e.agentId || e.agentId === agentId)
-    : index;
-
-  // 更新活跃 session 的状态
-  for (const entry of filtered) {
-    const active = conductorSessions.get(entry.sessionId);
-    if (active) {
-      entry.status = active.status;
-    }
-  }
-
-  ctx.sendToServer({
-    type: 'conductor_sessions_list',
-    requestId,
-    _requestClientId,
-    sessions: filtered.filter(e => !e.hidden)
-  });
-}
+// =====================================================================
+// Conductor Lifecycle
+// =====================================================================
 
 /**
- * 恢复已停止的 conductor session
+ * Initialize or restore the single Conductor instance.
+ * Called when user opens the Conductor UI.
  */
-export async function resumeConductorSession(msg) {
-  const { sessionId, userId, username } = msg;
-
-  // 已在内存中
-  if (conductorSessions.has(sessionId)) {
-    const session = conductorSessions.get(sessionId);
-    // 加载 UI 消息
-    if (!session.uiMessages || session.uiMessages.length === 0) {
-      const loaded = await loadSessionMessages(sessionId);
-      session.uiMessages = loaded.messages;
+export async function initConductor(msg) {
+  const { userId, username } = msg;
+
+  // Already initialized in memory — just send current state
+  if (conductor) {
+    if (!conductor.uiMessages || conductor.uiMessages.length === 0) {
+      const loaded = await loadConductorMessages();
+      conductor.uiMessages = loaded.messages;
     }
-    const cleaned = (session.uiMessages || []).map(m => {
+    const cleaned = (conductor.uiMessages || []).map(m => {
       const { _streaming, ...rest } = m;
       return rest;
     });
-    const dir = getSessionDataDir(sessionId);
+    const dir = getConductorHome();
     const hasOlderMessages = await getMaxShardIndex(dir) > 0;
 
+    // Load state.json for task info
+    const state = await loadState();
+
     sendConductorMessage({
-      type: 'conductor_session_restored',
-      sessionId,
-      name: session.name,
-      workDir: session.workDir,
-      scenarioId: session.scenarioId,
-      tasks: Array.from(session.tasks.values()),
-      userId: session.userId,
-      username: session.username,
+      type: 'conductor_opened',
+      tasks: state.tasks,
+      userId: conductor.userId,
+      username: conductor.username,
       uiMessages: cleaned,
-      hasOlderMessages
+      hasOlderMessages,
+      status: conductor.status
     });
-    sendStatusUpdate(session);
-    return;
+    sendStatusUpdate(conductor);
+    return conductor;
   }
 
-  // 从磁盘恢复
-  const meta = await loadSessionMeta(sessionId);
-  if (!meta) {
-    sendConductorMessage({
-      type: 'error', sessionId,
-      message: 'Conductor session not found'
-    });
-    return;
-  }
+  // Ensure conductor home directory exists
+  await ensureConductorHome();
 
-  const session = {
-    id: sessionId,
-    name: meta.name || '',
-    workDir: meta.workDir || null,
-    scenarioId: meta.scenarioId || null,
+  // Try restore from disk
+  const meta = await loadConductorMeta();
+
+  conductor = {
     status: 'running',
-    tasks: new Map((meta.tasks || []).map(t => [t.taskId, t])),
+    tasks: new Map(),
     conductorState: null,
-    costUsd: meta.costUsd || 0,
-    totalInputTokens: meta.totalInputTokens || 0,
-    totalOutputTokens: meta.totalOutputTokens || 0,
+    costUsd: meta?.costUsd || 0,
+    totalInputTokens: meta?.totalInputTokens || 0,
+    totalOutputTokens: meta?.totalOutputTokens || 0,
     activeClaudes: 0,
     uiMessages: [],
-    userId: userId || meta.userId,
-    username: username || meta.username,
-    agentId: meta.agentId || ctx.CONFIG?.agentName || null,
-    createdAt: meta.createdAt || Date.now(),
+    userId: userId || meta?.userId,
+    username: username || meta?.username,
+    createdAt: meta?.createdAt || Date.now(),
     _rotating: false,
     _conductorSemRelease: null
   };
 
-  conductorSessions.set(sessionId, session);
+  // Load state.json to populate tasks map
+  const state = await loadState();
+  for (const [taskId, entry] of Object.entries(state.tasks || {})) {
+    conductor.tasks.set(taskId, entry);
+  }
+
+  // Load UI messages from disk
+  const loaded = await loadConductorMessages();
+  conductor.uiMessages = loaded.messages;
 
-  const loaded = await loadSessionMessages(sessionId);
-  session.uiMessages = loaded.messages;
+  const isResume = !!meta;
 
   sendConductorMessage({
-    type: 'conductor_session_restored',
-    sessionId,
-    name: session.name,
-    workDir: session.workDir,
-    scenarioId: session.scenarioId,
-    tasks: Array.from(session.tasks.values()),
-    userId: session.userId,
-    username: session.username,
-    uiMessages: session.uiMessages,
-    hasOlderMessages: loaded.hasOlderMessages
+    type: 'conductor_opened',
+    tasks: state.tasks,
+    userId: conductor.userId,
+    username: conductor.username,
+    uiMessages: conductor.uiMessages,
+    hasOlderMessages: loaded.hasOlderMessages,
+    status: conductor.status,
+    resumed: isResume
   });
-  sendStatusUpdate(session);
+  sendStatusUpdate(conductor);
 
-  // 启动 Conductor Claude
+  // Start Conductor Claude
   try {
-    await createConductorClaude(session);
-    console.log(`[Conductor] Session ${sessionId} resumed, Claude ready`);
+    await createConductorClaude(conductor);
+    console.log(`[Conductor] ${isResume ? 'Resumed' : 'Created'}, Claude ready`);
   } catch (e) {
-    console.error('[Conductor] Failed to resume Claude:', e.message);
+    console.error('[Conductor] Failed to start Claude:', e.message);
+    sendConductorOutput(conductor, 'system', {
+      message: { role: 'assistant', content: `Conductor 启动失败: ${e.message}` }
+    });
   }
 
-  await upsertConductorIndex(session);
-  await saveSessionMeta(session);
+  await saveConductorMeta(conductor);
+  return conductor;
 }
 
 /**
- * 处理用户输入
+ * Handle user input to Conductor
  */
 export async function handleConductorUserInput(msg) {
-  const { sessionId, content } = msg;
-  const session = conductorSessions.get(sessionId);
-  if (!session) {
-    console.warn(`[Conductor] Session not found: ${sessionId}`);
+  const { content } = msg;
+  if (!conductor) {
+    console.warn('[Conductor] Not initialized, ignoring input');
     return;
   }
 
-  // 确保 session 在运行态（先检查再记录，避免停止态也记录消息）
-  if (session.status === 'stopped') {
+  if (conductor.status === 'stopped') {
     sendConductorMessage({
       type: 'conductor_error',
-      sessionId,
-      error: 'Session is stopped'
+      error: 'Conductor is stopped'
     });
     return;
   }
 
-  // 记录到 UI
-  recordUserMessage(session, content);
-
-  session.status = 'running';
-
-  // 发给 Conductor Claude
-  await sendToConductor(session, content);
-}
-
-/**
- * 更新工作路径
- */
-export async function handleUpdateWorkDir(msg) {
-  const { sessionId, workDir } = msg;
-  const session = conductorSessions.get(sessionId);
-  if (!session) return;
-
-  session.workDir = workDir;
-  console.log(`[Conductor] Session ${sessionId} workDir updated: ${workDir}`);
-
-  sendConductorMessage({
-    type: 'conductor_workdir_updated',
-    sessionId,
-    workDir
-  });
-  sendStatusUpdate(session);
-  await saveSessionMeta(session);
-}
-
-/**
- * 更新 session name
- */
-export async function handleUpdateConductorSession(msg) {
-  const { sessionId, name, workDir } = msg;
-  const session = conductorSessions.get(sessionId);
-  if (!session) return;
-
-  if (name !== undefined) session.name = name;
-  if (workDir !== undefined) session.workDir = workDir;
-  await saveSessionMeta(session);
-  await upsertConductorIndex(session);
+  recordUserMessage(conductor, content);
+  conductor.status = 'running';
+  await sendToConductor(conductor, content);
 }
 
 /**
- * 停止 session
+ * Stop Conductor
  */
-export async function stopConductorSession(sessionId) {
-  const session = conductorSessions.get(sessionId);
-  if (!session) return;
-
-  session.status = 'stopped';
+export async function stopConductor() {
+  if (!conductor) return;
 
-  // 停止 Conductor Claude
-  await stopConductorClaude(session);
+  conductor.status = 'stopped';
+  await stopConductorClaude(conductor);
 
-  sendConductorOutput(session, 'system', {
-    message: { role: 'assistant', content: 'Session 已停止' }
+  sendConductorOutput(conductor, 'system', {
+    message: { role: 'assistant', content: 'Conductor 已停止' }
   });
-  sendStatusUpdate(session);
-  await saveSessionMeta(session);
-  await upsertConductorIndex(session);
+  sendStatusUpdate(conductor);
+  await saveConductorMeta(conductor);
 
-  conductorSessions.delete(sessionId);
-  console.log(`[Conductor] Session ${sessionId} stopped`);
+  conductor = null;
+  console.log('[Conductor] Stopped');
 }
 
 /**
- * 清空 session
+ * Clear Conductor (reset messages, restart Claude)
  */
-export async function clearConductorSession(sessionId) {
-  const session = conductorSessions.get(sessionId);
-  if (!session) return;
+export async function clearConductor() {
+  if (!conductor) return;
 
-  // 停止 Claude
-  await stopConductorClaude(session);
+  await stopConductorClaude(conductor);
 
-  // 清空数据
-  session.tasks.clear();
-  session.uiMessages = [];
-  session.costUsd = 0;
-  session.totalInputTokens = 0;
-  session.totalOutputTokens = 0;
+  // Clear data but keep tasks
+  conductor.uiMessages = [];
+  conductor.costUsd = 0;
+  conductor.totalInputTokens = 0;
+  conductor.totalOutputTokens = 0;
 
-  const dir = getSessionDataDir(sessionId);
+  const dir = getConductorHome();
   await cleanupMessageShards(dir);
 
-  session.status = 'running';
+  conductor.status = 'running';
 
-  sendConductorMessage({
-    type: 'conductor_session_cleared',
-    sessionId
-  });
-  sendStatusUpdate(session);
+  sendConductorMessage({ type: 'conductor_cleared' });
+  sendStatusUpdate(conductor);
 
-  // 重启 Claude
+  // Restart Claude
   try {
-    await createConductorClaude(session);
+    await createConductorClaude(conductor);
   } catch (e) {
     console.error('[Conductor] Failed to restart Claude after clear:', e.message);
   }
 
-  await saveSessionMeta(session);
-  console.log(`[Conductor] Session ${sessionId} cleared`);
+  await saveConductorMeta(conductor);
+  console.log('[Conductor] Cleared');
 }

package/conductor/ui-messages.js

@@ -1,14 +1,16 @@
 /**
- * Conductor — UI 消息辅助函数
+ * Conductor — UI Message Helpers (V5)
  *
- * 与 crew/ui-messages.js 结构一致，但用 conductor_ 前缀的消息类型。
- * 核心职责：向 server 发送 WebSocket 消息，维护 uiMessages 持久化列表。
+ * Sends WebSocket messages to server/frontend.
+ * Maintains uiMessages persistence list on the conductor instance.
+ *
+ * No sessionId — Conductor is a singleton per Agent.
  */
 import ctx from '../context.js';
-import { upsertConductorIndex, saveSessionMeta } from './persistence.js';
+import { saveConductorMeta } from './persistence.js';
 
 /**
- * 发送 conductor 消息到 server（透传到 Web 前端）
+ * Send conductor message to server (forwarded to Web frontend)
  */
 export function sendConductorMessage(msg) {
   if (ctx.sendToServer) {
@@ -17,19 +19,18 @@ export function sendConductorMessage(msg) {
 }
 
 /**
- * 发送 Conductor Claude 的输出到前端
+ * Send Conductor Claude output to frontend
  * outputType: 'text' | 'tool_use' | 'tool_result' | 'system' | 'task_created' | 'task_forwarded'
  */
-export function sendConductorOutput(session, outputType, rawMessage, extra = {}) {
+export function sendConductorOutput(conductor, outputType, rawMessage, extra = {}) {
   sendConductorMessage({
     type: 'conductor_output',
-    sessionId: session.id,
     outputType,
     data: rawMessage,
     ...extra
   });
 
-  // 记录精简 UI 消息
+  // Record trimmed UI messages
   if (outputType === 'text') {
     const content = rawMessage?.message?.content;
     let text = '';
@@ -39,10 +40,9 @@ export function sendConductorOutput(session, outputType, rawMessage, extra = {})
       text = content.filter(b => b.type === 'text').map(b => b.text).join('');
     }
     if (!text) return;
-    // 反向查找 streaming 消息
     let found = false;
-    for (let i = session.uiMessages.length - 1; i >= 0; i--) {
-      const msg = session.uiMessages[i];
+    for (let i = conductor.uiMessages.length - 1; i >= 0; i--) {
+      const msg = conductor.uiMessages[i];
       if (msg.source === 'conductor' && msg.type === 'text' && msg._streaming) {
         msg.content += text;
         found = true;
@@ -50,7 +50,7 @@ export function sendConductorOutput(session, outputType, rawMessage, extra = {})
       }
     }
     if (!found) {
-      session.uiMessages.push({
+      conductor.uiMessages.push({
         source: 'conductor', type: 'text', content: text,
         _streaming: true, timestamp: Date.now()
       });
@@ -61,25 +61,25 @@ export function sendConductorOutput(session, outputType, rawMessage, extra = {})
     if (typeof content === 'string') text = content;
     else if (Array.isArray(content)) text = content.filter(b => b.type === 'text').map(b => b.text).join('');
     if (!text) return;
-    session.uiMessages.push({
+    conductor.uiMessages.push({
       source: 'conductor', type: 'system', content: text, timestamp: Date.now()
     });
   } else if (outputType === 'task_created') {
-    session.uiMessages.push({
+    conductor.uiMessages.push({
       source: 'conductor', type: 'task_created',
       taskId: extra.taskId, taskTitle: extra.taskTitle,
       content: `Created task: ${extra.taskTitle}`,
       timestamp: Date.now()
     });
   } else if (outputType === 'task_forwarded') {
-    session.uiMessages.push({
+    conductor.uiMessages.push({
       source: 'conductor', type: 'task_forwarded',
       taskId: extra.taskId,
       content: `Forwarded message to task: ${extra.taskId}`,
       timestamp: Date.now()
     });
   } else if (outputType === 'tool_use') {
-    endConductorStreaming(session);
+    endConductorStreaming(conductor);
     const content = rawMessage?.message?.content;
     if (Array.isArray(content)) {
       for (const block of content) {
@@ -89,7 +89,7 @@ export function sendConductorOutput(session, outputType, rawMessage, extra = {})
           if (input.file_path) trimmedInput.file_path = input.file_path;
           if (input.command) trimmedInput.command = input.command.substring(0, 200);
           if (input.pattern) trimmedInput.pattern = input.pattern;
-          session.uiMessages.push({
+          conductor.uiMessages.push({
             source: 'conductor', type: 'tool',
             toolName: block.name, toolId: block.id,
             toolInput: Object.keys(trimmedInput).length > 0 ? trimmedInput : null,
@@ -103,9 +103,9 @@ export function sendConductorOutput(session, outputType, rawMessage, extra = {})
   } else if (outputType === 'tool_result') {
     const toolId = rawMessage?.message?.tool_use_id;
     if (toolId) {
-      for (let i = session.uiMessages.length - 1; i >= 0; i--) {
-        if (session.uiMessages[i].type === 'tool' && session.uiMessages[i].toolId === toolId) {
-          session.uiMessages[i].hasResult = true;
+      for (let i = conductor.uiMessages.length - 1; i >= 0; i--) {
+        if (conductor.uiMessages[i].type === 'tool' && conductor.uiMessages[i].toolId === toolId) {
+          conductor.uiMessages[i].hasResult = true;
           break;
         }
       }
@@ -114,56 +114,57 @@ export function sendConductorOutput(session, outputType, rawMessage, extra = {})
 }
 
 /**
- * 结束 Conductor 的 streaming 消息
+ * End Conductor streaming message
  */
-export function endConductorStreaming(session) {
-  for (let i = session.uiMessages.length - 1; i >= 0; i--) {
-    if (session.uiMessages[i].source === 'conductor' && session.uiMessages[i]._streaming) {
-      delete session.uiMessages[i]._streaming;
+export function endConductorStreaming(conductor) {
+  for (let i = conductor.uiMessages.length - 1; i >= 0; i--) {
+    if (conductor.uiMessages[i].source === 'conductor' && conductor.uiMessages[i]._streaming) {
+      delete conductor.uiMessages[i]._streaming;
       break;
     }
   }
 }
 
 /**
- * 记录用户消息到 uiMessages
+ * Record user message to uiMessages
  */
-export function recordUserMessage(session, content) {
-  session.uiMessages.push({
+export function recordUserMessage(conductor, content) {
+  conductor.uiMessages.push({
     source: 'user', type: 'text', content,
     timestamp: Date.now()
   });
 }
 
 /**
- * 发送 session 状态更新到前端
+ * Send conductor status update to frontend
  */
-export function sendStatusUpdate(session) {
-  const tasks = Array.from(session.tasks.values()).map(t => ({
-    taskId: t.taskId,
-    title: t.title,
-    workDir: t.workDir,
-    status: t.status,
-    phase: t.phase,
-    progress: t.progress,
-    activeActors: t.activeActors || [],
-    createdAt: t.createdAt,
-    updatedAt: t.updatedAt
-  }));
+export function sendStatusUpdate(conductor) {
+  const tasks = {};
+  for (const [taskId, t] of conductor.tasks) {
+    tasks[taskId] = {
+      taskId: t.taskId,
+      title: t.title,
+      workDir: t.workDir,
+      scenario: t.scenario,
+      status: t.status,
+      activeActors: t.activeActors || [],
+      currentStep: t.currentStep || '',
+      lastUpdate: t.lastUpdate || t.updatedAt
+    };
+  }
 
   sendConductorMessage({
     type: 'conductor_status',
-    sessionId: session.id,
-    status: session.status,
-    workDir: session.workDir,
+    status: conductor.status,
     tasks,
-    costUsd: session.costUsd,
-    totalInputTokens: session.totalInputTokens,
-    totalOutputTokens: session.totalOutputTokens,
-    activeClaudes: session.activeClaudes || 0
+    costUsd: conductor.costUsd,
+    totalInputTokens: conductor.totalInputTokens,
+    totalOutputTokens: conductor.totalOutputTokens,
+    activeClaudes: conductor.activeClaudes || 0
   });
 
-  // 异步持久化
-  upsertConductorIndex(session).catch(e => console.warn('[Conductor] Failed to update index:', e.message));
-  saveSessionMeta(session).catch(e => console.warn('[Conductor] Failed to save meta:', e.message));
+  // Async persist
+  saveConductorMeta(conductor).catch(e =>
+    console.warn('[Conductor] Failed to save meta:', e.message)
+  );
 }