@yeaft/webchat-agent 0.1.225 → 0.1.226

package/conductor/conductor-claude.js

@@ -1,12 +1,13 @@
 /**
- * Conductor — Conductor Claude 实例管理
+ * Conductor — Conductor Claude Instance (V5)
  *
- * Conductor Claude 是常驻的 Claude Code 进程，负责：
- * 1. 消息分类（简单问答 / 创建 task / 透传到 task / 查状态）
- * 2. 回答简单问题
- * 3. 绝不做任务分析或步骤拆解
+ * Conductor Claude is a persistent Claude Code process that:
+ * 1. Classifies messages (Q&A / create task / forward to task / status)
+ * 2. Answers simple questions
+ * 3. Never does task analysis or step decomposition
  *
- * 复用 V1 的 role-query 模式：query() + Stream + for-await 循环。
+ * cwd = Conductor Home (~/.config/yeaft-agent/.conductor/)
+ * State.json summary injected into systemPrompt for task awareness.
  */
 import { query, Stream } from '../sdk/index.js';
 import { promises as fs } from 'fs';
@@ -16,22 +17,25 @@ import {
   sendConductorMessage, sendConductorOutput,
   endConductorStreaming, sendStatusUpdate
 } from './ui-messages.js';
-import { getSessionDataDir } from './persistence.js';
+import {
+  getConductorHome, ensureConductorHome,
+  loadState, saveState, updateTaskInState, initTaskDir
+} from './persistence.js';
 
 // =====================================================================
-// Session ID Persistence (Conductor Claude session)
+// Claude Session ID Persistence
 // =====================================================================
 
-async function saveConductorSessionId(sessionDataDir, claudeSessionId) {
-  await fs.mkdir(sessionDataDir, { recursive: true });
-  const filePath = join(sessionDataDir, 'conductor-claude-session.json');
+async function saveConductorSessionId(claudeSessionId) {
+  const dir = await ensureConductorHome();
+  const filePath = join(dir, 'claude-session.json');
   await fs.writeFile(filePath, JSON.stringify({
     claudeSessionId, savedAt: Date.now()
   }));
 }
 
-async function loadConductorSessionId(sessionDataDir) {
-  const filePath = join(sessionDataDir, 'conductor-claude-session.json');
+async function loadConductorSessionId() {
+  const filePath = join(getConductorHome(), 'claude-session.json');
   try {
     const data = JSON.parse(await fs.readFile(filePath, 'utf-8'));
     return data.claudeSessionId || null;
@@ -40,8 +44,8 @@ async function loadConductorSessionId(sessionDataDir) {
   }
 }
 
-async function clearConductorSessionId(sessionDataDir) {
-  const filePath = join(sessionDataDir, 'conductor-claude-session.json');
+async function clearConductorSessionId() {
+  const filePath = join(getConductorHome(), 'claude-session.json');
   try { await fs.unlink(filePath); } catch { /* ok */ }
 }
 
@@ -49,16 +53,20 @@ async function clearConductorSessionId(sessionDataDir) {
 // System Prompt
 // =====================================================================
 
-function buildConductorSystemPrompt(session) {
-  const taskSummaries = Array.from(session.tasks.values())
-    .map(t => `- ${t.taskId}: ${t.title} [${t.phase} ${t.progress}%] @ ${t.workDir}`)
-    .join('\n');
+function buildConductorSystemPrompt(conductor) {
+  // Build task summaries from in-memory tasks map
+  const taskLines = [];
+  for (const [taskId, t] of conductor.tasks) {
+    const actors = (t.activeActors || []).join(', ');
+    taskLines.push(`- ${taskId}: ${t.title} [${t.status}${t.currentStep ? ' ' + t.currentStep : ''}] workDir=${t.workDir} scenario=${t.scenario}${actors ? ' actors=' + actors : ''}`);
+  }
+  const taskSummaries = taskLines.join('\n');
 
   return `# Conductor — 交响乐指挥台
 
 你是 Conductor，项目的总指挥。你的职责是：
 1. **分类消息**：判断用户的输入是简单问答还是需要创建任务
-2. **创建任务**：通过 CREATE_TASK 指令创建新任务
+2. **创建任务**：通过 CREATE_TASK 指令创建新任务（必须指定 workDir 和 scenario）
 3. **转发消息**：通过 FORWARD_TASK 将用户消息传递给已有任务
 4. **回答问题**：直接回答简单的问题
 5. **汇报状态**：用户询问进度时汇总所有任务状态
@@ -69,9 +77,6 @@ function buildConductorSystemPrompt(session) {
 - 不评估需要几个人
 - 不写代码
 
-## 当前工作路径
-${session.workDir || '(未设置)'}
-
 ## 当前活跃任务
 ${taskSummaries || '(无)'}
 
@@ -83,6 +88,8 @@ ${taskSummaries || '(无)'}
 \`\`\`
 ---CREATE_TASK---
 title: <任务标题>
+workDir: <项目工作路径>
+scenario: <dev|writing|trading|video>
 ---END_CREATE_TASK---
 \`\`\`
 
@@ -102,6 +109,8 @@ message: <要转发的内容>
 ## 规则
 - 每条用户消息只需要一种响应：创建任务 / 转发 / 直接回答
 - 创建任务时只给标题，不要描述实现步骤
+- 创建任务时必须指定 workDir（用户提到的项目路径）和 scenario（场景类型）
+- 如果用户没指定 workDir 或 scenario，先询问
 - 如果用户问"进度怎样"，直接汇总上面的任务列表状态
 - 保持回复简洁
 - 用中文回复`;
@@ -112,25 +121,25 @@ message: <要转发的内容>
 // =====================================================================
 
 /**
- * 创建或重建 Conductor Claude 实例
+ * Create or rebuild Conductor Claude instance
  */
-export async function createConductorClaude(session) {
-  const sessionDataDir = getSessionDataDir(session.id);
+export async function createConductorClaude(conductor) {
+  const conductorHome = await ensureConductorHome();
 
-  // 获取信号量
+  // Acquire semaphore
   const release = await globalSemaphore.acquire();
-  session._conductorSemRelease = release;
-  session.activeClaudes = (session.activeClaudes || 0) + 1;
+  conductor._conductorSemRelease = release;
+  conductor.activeClaudes = (conductor.activeClaudes || 0) + 1;
 
   const inputStream = new Stream();
   const abortController = new AbortController();
-  const systemPrompt = buildConductorSystemPrompt(session);
+  const systemPrompt = buildConductorSystemPrompt(conductor);
 
-  // 尝试恢复已有 session
-  const savedSessionId = await loadConductorSessionId(sessionDataDir);
+  // Try to resume existing Claude session
+  const savedSessionId = await loadConductorSessionId();
 
   const queryOptions = {
-    cwd: sessionDataDir,
+    cwd: conductorHome,
     permissionMode: 'bypassPermissions',
     abort: abortController.signal,
     appendSystemPrompt: systemPrompt
@@ -146,7 +155,7 @@ export async function createConductorClaude(session) {
     options: queryOptions
   });
 
-  session.conductorState = {
+  conductor.conductorState = {
     query: conductorQuery,
     inputStream,
     abortController,
@@ -158,26 +167,24 @@ export async function createConductorClaude(session) {
     lastOutputTokens: 0
   };
 
-  // 启动输出处理循环
-  processConductorOutput(session, conductorQuery);
+  // Start output processing loop
+  processConductorOutput(conductor, conductorQuery);
 
-  return session.conductorState;
+  return conductor.conductorState;
 }
 
 /**
- * 向 Conductor Claude 发送消息
+ * Send message to Conductor Claude
  */
-export async function sendToConductor(session, content) {
-  let state = session.conductorState;
+export async function sendToConductor(conductor, content) {
+  let state = conductor.conductorState;
 
   if (!state || !state.query || !state.inputStream) {
-    state = await createConductorClaude(session);
+    state = await createConductorClaude(conductor);
   }
 
-  // 更新 system prompt（动态注入最新 task 列表）
-  // 注意：Claude Code 不支持动态更新 system prompt
-  // 所以我们在用户消息前注入上下文
-  const taskContext = buildTaskContext(session);
+  // Inject task context before user message
+  const taskContext = buildTaskContext(conductor);
   const fullContent = taskContext
     ? `${content}\n\n---\n<conductor-context>\n${taskContext}\n</conductor-context>`
     : content;
@@ -189,14 +196,15 @@ export async function sendToConductor(session, content) {
     message: { role: 'user', content: fullContent }
   });
 
-  sendStatusUpdate(session);
+  sendStatusUpdate(conductor);
 }
 
-function buildTaskContext(session) {
-  if (session.tasks.size === 0) return null;
-  const lines = ['当前工作路径: ' + (session.workDir || '(未设置)'), '', '活跃任务:'];
-  for (const t of session.tasks.values()) {
-    lines.push(`- ${t.taskId}: ${t.title} [${t.phase} ${t.progress}%] @ ${t.workDir}`);
+function buildTaskContext(conductor) {
+  if (conductor.tasks.size === 0) return null;
+  const lines = ['活跃任务:'];
+  for (const [taskId, t] of conductor.tasks) {
+    const actors = (t.activeActors || []).join(', ');
+    lines.push(`- ${taskId}: ${t.title} [${t.status}] workDir=${t.workDir} scenario=${t.scenario}${actors ? ' actors=' + actors : ''}`);
   }
   return lines.join('\n');
 }
@@ -205,22 +213,28 @@ function buildTaskContext(session) {
 // Output Processing
 // =====================================================================
 
-// 解析 CREATE_TASK 指令
+// Parse CREATE_TASK instruction (V5: includes workDir and scenario)
 function parseCreateTask(text) {
   const regex = /---CREATE_TASK---\s*\n([\s\S]*?)---END_CREATE_TASK---/g;
   const tasks = [];
   let match;
   while ((match = regex.exec(text)) !== null) {
     const block = match[1];
-    const titleMatch = block.match(/title:\s*(.+)/i);
+    const titleMatch = block.match(/^title:\s*(.+)/im);
+    const workDirMatch = block.match(/^workDir:\s*(.+)/im);
+    const scenarioMatch = block.match(/^scenario:\s*(.+)/im);
     if (titleMatch) {
-      tasks.push({ title: titleMatch[1].trim() });
+      tasks.push({
+        title: titleMatch[1].trim(),
+        workDir: workDirMatch ? workDirMatch[1].trim() : '',
+        scenario: scenarioMatch ? scenarioMatch[1].trim() : 'dev'
+      });
     }
   }
   return tasks;
 }
 
-// 解析 FORWARD_TASK 指令
+// Parse FORWARD_TASK instruction
 function parseForwardTask(text) {
   const regex = /---FORWARD_TASK---\s*\n([\s\S]*?)---END_FORWARD_TASK---/g;
   const forwards = [];
@@ -228,7 +242,8 @@ function parseForwardTask(text) {
   while ((match = regex.exec(text)) !== null) {
     const block = match[1];
     const taskIdMatch = block.match(/^taskId:\s*(.+)/im);
-    const messageMatch = block.match(/^message:\s*([\s\S]*?)$/im);
+    // message may be multi-line: capture from "message:" to end of block
+    const messageMatch = block.match(/^message:\s*([\s\S]*)$/im);
     if (taskIdMatch) {
       forwards.push({
         taskId: taskIdMatch[1].trim(),
@@ -240,15 +255,14 @@ function parseForwardTask(text) {
 }
 
 /**
- * 处理 Conductor Claude 的流式输出
+ * Process Conductor Claude streaming output
  */
-async function processConductorOutput(session, conductorQuery) {
-  const state = session.conductorState;
-  const sessionDataDir = getSessionDataDir(session.id);
+async function processConductorOutput(conductor, conductorQuery) {
+  const state = conductor.conductorState;
 
   try {
     for await (const message of conductorQuery) {
-      if (session.status === 'stopped') break;
+      if (conductor.status === 'stopped') break;
 
       if (message.type === 'system' && message.subtype === 'init') {
         state.claudeSessionId = message.session_id;
@@ -261,7 +275,7 @@ async function processConductorOutput(session, conductorQuery) {
         if (content) {
           if (typeof content === 'string') {
             state.accumulatedText += content;
-            sendConductorOutput(session, 'text', message);
+            sendConductorOutput(conductor, 'text', message);
           } else if (Array.isArray(content)) {
             let hasText = false;
             for (const block of content) {
@@ -269,96 +283,110 @@ async function processConductorOutput(session, conductorQuery) {
                 state.accumulatedText += block.text;
                 hasText = true;
               } else if (block.type === 'tool_use') {
-                endConductorStreaming(session);
-                sendConductorOutput(session, 'tool_use', message);
+                endConductorStreaming(conductor);
+                sendConductorOutput(conductor, 'tool_use', message);
               }
             }
             if (hasText) {
-              sendConductorOutput(session, 'text', message);
+              sendConductorOutput(conductor, 'text', message);
             }
           }
         }
       } else if (message.type === 'user') {
-        sendConductorOutput(session, 'tool_result', message);
+        sendConductorOutput(conductor, 'tool_result', message);
       } else if (message.type === 'result') {
-        // Turn 完成
-        console.log(`[Conductor] Turn completed`);
-        endConductorStreaming(session);
+        // Turn completed
+        console.log('[Conductor] Turn completed');
+        endConductorStreaming(conductor);
 
-        // 更新费用
+        // Update costs
         if (message.total_cost_usd != null) {
           const costDelta = message.total_cost_usd - state.lastCostUsd;
-          if (costDelta > 0) session.costUsd += costDelta;
+          if (costDelta > 0) conductor.costUsd += costDelta;
           state.lastCostUsd = message.total_cost_usd;
         }
         if (message.usage) {
           const inputDelta = (message.usage.input_tokens || 0) - (state.lastInputTokens || 0);
           const outputDelta = (message.usage.output_tokens || 0) - (state.lastOutputTokens || 0);
-          if (inputDelta > 0) session.totalInputTokens += inputDelta;
-          if (outputDelta > 0) session.totalOutputTokens += outputDelta;
+          if (inputDelta > 0) conductor.totalInputTokens += inputDelta;
+          if (outputDelta > 0) conductor.totalOutputTokens += outputDelta;
           state.lastInputTokens = message.usage.input_tokens || 0;
           state.lastOutputTokens = message.usage.output_tokens || 0;
         }
 
-        // 持久化 sessionId
+        // Persist Claude session ID
         if (state.claudeSessionId) {
-          saveConductorSessionId(sessionDataDir, state.claudeSessionId)
+          saveConductorSessionId(state.claudeSessionId)
             .catch(e => console.warn('[Conductor] Failed to save sessionId:', e.message));
         }
 
-        // 解析指令
+        // Parse instructions
         const createTasks = parseCreateTask(state.accumulatedText);
         const forwardTasks = parseForwardTask(state.accumulatedText);
 
-        // 处理 CREATE_TASK
+        // Handle CREATE_TASK
         for (const ct of createTasks) {
           const taskId = `task-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`;
-          const task = {
+
+          // Create task directory at {workDir}/.conductor/{taskId}/ (includes worktree)
+          let worktreePath = null;
+          if (ct.workDir) {
+            try {
+              const result = await initTaskDir(ct.workDir, taskId);
+              worktreePath = result.worktreePath || null;
+            } catch (e) {
+              console.warn(`[Conductor] Failed to create task dir: ${e.message}`);
+            }
+          }
+
+          // Register in state.json
+          const taskEntry = {
             taskId,
             title: ct.title,
-            workDir: session.workDir || '',
-            status: 'pending',
-            phase: 'created',
-            progress: 0,
+            workDir: ct.workDir,
+            scenario: ct.scenario,
+            status: 'created',
             activeActors: [],
-            createdAt: Date.now(),
-            updatedAt: Date.now()
+            currentStep: '',
+            worktreePath,
+            lastUpdate: Date.now()
           };
-          session.tasks.set(taskId, task);
+          conductor.tasks.set(taskId, taskEntry);
 
-          sendConductorOutput(session, 'task_created', null, {
+          await updateTaskInState(taskId, taskEntry).catch(e =>
+            console.warn('[Conductor] Failed to update state.json:', e.message)
+          );
+
+          sendConductorOutput(conductor, 'task_created', null, {
             taskId, taskTitle: ct.title
           });
 
           sendConductorMessage({
             type: 'conductor_task_created',
-            sessionId: session.id,
-            task
+            task: taskEntry
           });
 
-          console.log(`[Conductor] Task created: ${taskId} — ${ct.title}`);
+          console.log(`[Conductor] Task created: ${taskId} — ${ct.title} @ ${ct.workDir} (${ct.scenario})`);
         }
 
-        // 处理 FORWARD_TASK
+        // Handle FORWARD_TASK
         for (const ft of forwardTasks) {
-          const task = session.tasks.get(ft.taskId);
+          const task = conductor.tasks.get(ft.taskId);
           if (task) {
-            // 将消息写入 task 的 inbox（后续 orchestrator 读取）
             if (!task.inbox) task.inbox = [];
             task.inbox.push({
               from: 'conductor',
               content: ft.message,
               timestamp: Date.now()
             });
-            task.updatedAt = Date.now();
+            task.lastUpdate = Date.now();
 
-            sendConductorOutput(session, 'task_forwarded', null, {
+            sendConductorOutput(conductor, 'task_forwarded', null, {
               taskId: ft.taskId
             });
 
             sendConductorMessage({
               type: 'conductor_task_message',
-              sessionId: session.id,
               taskId: ft.taskId,
               message: ft.message
             });
@@ -372,19 +400,16 @@ async function processConductorOutput(session, conductorQuery) {
         state.accumulatedText = '';
         state.turnActive = false;
 
-        sendConductorMessage({
-          type: 'conductor_turn_completed',
-          sessionId: session.id
-        });
-        sendStatusUpdate(session);
+        sendConductorMessage({ type: 'conductor_turn_completed' });
+        sendStatusUpdate(conductor);
       }
     }
   } catch (error) {
     if (error.name === 'AbortError') {
-      console.log(`[Conductor] Claude aborted`);
+      console.log('[Conductor] Claude aborted');
     } else {
-      console.error(`[Conductor] Claude error:`, error.message);
-      endConductorStreaming(session);
+      console.error('[Conductor] Claude error:', error.message);
+      endConductorStreaming(conductor);
       state.turnActive = false;
       state.query = null;
       state.inputStream = null;
@@ -392,35 +417,30 @@ async function processConductorOutput(session, conductorQuery) {
 
       sendConductorMessage({
         type: 'conductor_error',
-        sessionId: session.id,
         error: error.message.substring(0, 500)
       });
 
-      // 转入等待用户
-      session.status = 'waiting_user';
-      sendStatusUpdate(session);
+      conductor.status = 'waiting_user';
+      sendStatusUpdate(conductor);
     }
   } finally {
-    // 释放信号量
-    if (session._conductorSemRelease) {
-      session._conductorSemRelease();
-      session._conductorSemRelease = null;
-      session.activeClaudes = Math.max(0, (session.activeClaudes || 1) - 1);
+    if (conductor._conductorSemRelease) {
+      conductor._conductorSemRelease();
+      conductor._conductorSemRelease = null;
+      conductor.activeClaudes = Math.max(0, (conductor.activeClaudes || 1) - 1);
     }
   }
 }
 
 /**
- * 停止 Conductor Claude
+ * Stop Conductor Claude
  */
-export async function stopConductorClaude(session) {
-  const state = session.conductorState;
+export async function stopConductorClaude(conductor) {
+  const state = conductor.conductorState;
   if (!state) return;
 
-  const sessionDataDir = getSessionDataDir(session.id);
-
   if (state.claudeSessionId) {
-    await saveConductorSessionId(sessionDataDir, state.claudeSessionId)
+    await saveConductorSessionId(state.claudeSessionId)
       .catch(e => console.warn('[Conductor] Failed to save sessionId:', e.message));
   }
 
@@ -431,23 +451,22 @@ export async function stopConductorClaude(session) {
   state.query = null;
   state.inputStream = null;
   state.turnActive = false;
-  session.conductorState = null;
+  conductor.conductorState = null;
 
-  if (session._conductorSemRelease) {
-    session._conductorSemRelease();
-    session._conductorSemRelease = null;
-    session.activeClaudes = Math.max(0, (session.activeClaudes || 1) - 1);
+  if (conductor._conductorSemRelease) {
+    conductor._conductorSemRelease();
+    conductor._conductorSemRelease = null;
+    conductor.activeClaudes = Math.max(0, (conductor.activeClaudes || 1) - 1);
   }
 }
 
 /**
- * 清空 Conductor Claude（强制新建对话）
+ * Clear Conductor Claude (force new conversation)
  */
-export async function clearConductorClaude(session) {
-  await stopConductorClaude(session);
-  const sessionDataDir = getSessionDataDir(session.id);
-  await clearConductorSessionId(sessionDataDir);
+export async function clearConductorClaude(conductor) {
+  await stopConductorClaude(conductor);
+  await clearConductorSessionId();
 }
 
-// 导出解析函数供测试用
+// Export parse functions for testing
 export { parseCreateTask, parseForwardTask };

package/conductor/index.js

@@ -1,12 +1,12 @@
 /**
- * Conductor — 模块入口
+ * Conductor — Module Entry
  *
- * 导出三大核心子系统：
- * 1. Personas — 18 个人物定义（4 场景）
- * 2. Specialties — specialty 行为定义（通用 + 场景特有）
- * 3. CLAUDE.md Generator — 三段式动态生成
- * 4. Actor — Claude 实例创建/管理/释放
- * 5. Worktree — 按线程的 worktree 管理
+ * Exports three core subsystems:
+ * 1. Personas — 18 persona definitions (4 scenarios)
+ * 2. Specialties — specialty behavior definitions
+ * 3. CLAUDE.md Generator — dynamic 3-section generation
+ * 4. Actor — Claude instance create/manage/release
+ * 5. Worktree — per-task worktree management
  */
 
 // ---- Personas ----
@@ -57,7 +57,9 @@ export {
 
 // ---- Worktree Management ----
 export {
-  createThreadWorktree,
-  cleanupTaskWorktrees,
-  cleanupAllConductorWorktrees
+  createTaskWorktree,
+  cleanupTaskWorktree,
+  cleanupAllConductorWorktrees,
+  getTaskWorktreePath,
+  getActorCwd
 } from './worktree.js';