@yeaft/webchat-agent 1.0.78 → 1.0.79

package/connection/buffer.js

@@ -9,7 +9,11 @@ export const BUFFERABLE_TYPES = new Set([
   'turn_completed', 'conversation_closed',
   'session_id_update', 'compact_status', 'slash_commands_update',
   'background_task_started', 'background_task_output',
-  'subagent_started', 'subagent_message', 'subagent_completed'
+  'subagent_started', 'subagent_message', 'subagent_completed',
+  'crew_output', 'crew_status', 'crew_turn_completed',
+  'crew_session_created', 'crew_session_restored', 'crew_human_needed',
+  'crew_role_added', 'crew_role_removed',
+  'crew_role_compact', 'crew_context_usage'
 ]);
 
 function bufferMessage(msg, reason) {
@@ -23,7 +27,7 @@ function bufferMessage(msg, reason) {
     return 'buffered';
   }
   // Buffer full: drop oldest non-status messages to make room
-  const dropIdx = ctx.messageBuffer.findIndex(m => m.type !== 'turn_completed');
+  const dropIdx = ctx.messageBuffer.findIndex(m => m.type !== 'crew_status' && m.type !== 'turn_completed');
   if (dropIdx >= 0) {
     ctx.messageBuffer.splice(dropIdx, 1);
     ctx.messageBuffer.push(msg);

package/connection/message-router.js

@@ -3,7 +3,11 @@
  *
  * task-330c lint guard:
  *   ⚠️ DO NOT introduce greedy `text.replace(/---ROUTE---[\s\S]*$/g, '')`
- *      style strips on routed message payloads.
+ *      style strips on routed message payloads. Crew ROUTE stripping is
+ *      owned EXCLUSIVELY by `agent/crew/routing.js` `parseRoutes()` which
+ *      returns `{routes, displayBody}` with exact ranges removed. A second
+ *      strip here would re-process already-cleaned text and risks both
+ *      double-strip artefacts and the trailing-prose bug fixed by task-328.
  */
 import ctx from '../context.js';
 import { decodeKey } from '../encryption.js';
@@ -22,6 +26,12 @@ import {
   sendConversationList, handleBtwQuestion, preloadSlashCommands,
   handlePingSession
 } from '../conversation.js';
+import {
+  createCrewSession, handleCrewHumanInput, handleCrewControl,
+  addRoleToSession, removeRoleFromSession,
+  handleListCrewSessions, handleCheckCrewExists, handleDeleteCrewDir, resumeCrewSession, removeFromCrewIndex,
+  handleLoadCrewHistory, handleCheckCrewContext
+} from '../crew.js';
 import { sendToServer, flushMessageBuffer } from './buffer.js';
 import { handleRestartAgent, handleUpgradeAgent } from './upgrade.js';
 import { loadMcpServers, updateMcpConfig } from '../mcp.js';
@@ -108,6 +118,10 @@ export async function handleMessage(msg) {
       preloadSlashCommands().catch(() => {});
       break;
 
+    case 'check_crew_context':
+      handleCheckCrewContext(msg);
+      break;
+
     case 'resume_conversation':
       await resumeConversation(msg);
       break;
@@ -248,6 +262,55 @@ export async function handleMessage(msg) {
       handleAskUserAnswer(msg);
       break;
 
+    // Crew (multi-agent) messages
+    case 'create_crew_session':
+      await createCrewSession(msg);
+      break;
+
+    case 'crew_human_input':
+      await handleCrewHumanInput(msg);
+      break;
+
+    case 'crew_control':
+      await handleCrewControl(msg);
+      break;
+
+    case 'crew_add_role':
+      await addRoleToSession(msg);
+      break;
+
+    case 'crew_remove_role':
+      await removeRoleFromSession(msg);
+      break;
+
+    case 'list_crew_sessions':
+      await handleListCrewSessions(msg);
+      break;
+
+    case 'check_crew_exists':
+      await handleCheckCrewExists(msg);
+      break;
+
+    case 'delete_crew_dir':
+      await handleDeleteCrewDir(msg);
+      break;
+
+    case 'resume_crew_session':
+      await resumeCrewSession(msg);
+      break;
+
+    case 'delete_crew_session':
+      await removeFromCrewIndex(msg.sessionId);
+      (await import('../conversation.js')).sendConversationList();
+      break;
+
+    case 'update_crew_session':
+      await (await import('../crew.js')).handleUpdateCrewSession(msg);
+      break;
+
+    case 'crew_load_history':
+      await handleLoadCrewHistory(msg);
+      break;
 
     // Port proxy
     case 'proxy_request':

package/conversation.js

@@ -5,6 +5,7 @@ import ctx from './context.js';
 import { query } from './sdk/index.js';
 import { loadSessionHistory } from './history.js';
 import { startClaudeQuery } from './claude.js';
+import { crewSessions } from './crew.js';
 import { getProvider, DEFAULT_PROVIDER, isValidProvider } from './providers/index.js';
 
 // 不支持的斜杠命令（真正需要交互式 CLI 的命令）
@@ -190,7 +191,7 @@ function prestartClaude(conversationId, workDir, resumeSessionId) {
  *
  * @param {string} [workDir] - Project directory (default: agent workDir)
  * @param {string} [targetId] - conversationId to key the update to
- *                               ('__preload__' for agent-level)
+ *                               ('__preload__' for agent-level, or crewSessionId)
  */
 export async function preloadSlashCommands(workDir, targetId = '__preload__') {
   const effectiveWorkDir = workDir || ctx.CONFIG.workDir;
@@ -282,7 +283,7 @@ export function parseSlashCommand(message) {
   return { type: null, message };
 }
 
-// 发送 conversation 列表。
+// 发送 conversation 列表（仅含活跃 crew sessions；历史 Crew 索引按需通过 list_crew_sessions 加载）
 export async function sendConversationList() {
   const list = [];
   for (const [id, state] of ctx.conversations) {
@@ -304,6 +305,19 @@ export async function sendConversationList() {
     };
     list.push(entry);
   }
+  // 追加活跃 crew sessions。历史 Crew 索引可能触发磁盘读取，保持按需加载，
+  // 由显式 list_crew_sessions 请求处理，避免普通 Chat/Yeaft 列表提前加载 Crew。
+  for (const [id, session] of crewSessions) {
+    list.push({
+      id,
+      workDir: session.projectDir,
+      createdAt: session.createdAt,
+      processing: session.status === 'running',
+      userId: session.userId,
+      username: session.username,
+      type: 'crew',
+    });
+  }
   ctx.sendToServer({
     type: 'conversation_list',
     conversations: list
@@ -1032,16 +1046,19 @@ export function handleAskUserAnswer(msg) {
 }
 
 /**
- * Handle /btw side question.
+ * Handle /btw side question — supports multi-turn and Crew mode.
  *
  * Multi-turn: First question forks the session (forkSession: true).
  * Subsequent questions resume the forked session (no fork).
  * The forked session ID is captured from system init and returned in btw_done.
+ *
+ * Crew mode: If conversationId is a crew session, use the decision maker's
+ * claudeSessionId as the base for forking.
  */
 export async function handleBtwQuestion(msg) {
   const { conversationId, question, btwSessionId } = msg;
 
-  // 1. Find the base chat session.
+  // 1. Find the base session — Chat or Crew decision maker
   let baseSessionId = null;
   let workDir = null;
 
@@ -1049,6 +1066,17 @@ export async function handleBtwQuestion(msg) {
   if (chatState?.claudeSessionId) {
     baseSessionId = chatState.claudeSessionId;
     workDir = chatState.workDir;
+  } else {
+    // Crew mode: find decision maker's session
+    const crewSession = crewSessions.get(conversationId);
+    if (crewSession) {
+      const dmName = crewSession.decisionMaker;
+      const dmState = dmName ? crewSession.roleStates.get(dmName) : null;
+      if (dmState?.claudeSessionId) {
+        baseSessionId = dmState.claudeSessionId;
+        workDir = crewSession.projectDir;
+      }
+    }
   }
 
   if (!baseSessionId) {

package/crew/builtin-actions.js

@@ -0,0 +1,154 @@
+/**
+ * Crew — built-in role actions (task-330a §B)
+ *
+ * These two actions replace the "PM 给自己发闭环消息" anti-pattern that
+ * task-330a §A now rejects at the routing layer:
+ *
+ *   • taskClose(session, { taskId, summary, fromRole })
+ *       — directly mark the task complete on the kanban + broadcast a
+ *         status card via sendCrewMessage. No ROUTE round-trip.
+ *
+ *   • roleStandby(session, { role, reason, fromRole })
+ *       — flip a role's runtime state to 'standby' and broadcast.
+ *         Persistence to .crew/context/role-states.json is a 330d
+ *         concern — we only define the in-memory contract here.
+ *
+ * Both functions are pure server-side helpers. They do NOT consume a
+ * routing turn (no session.round++, no dispatchToRole). Callers that
+ * choose to expose them as Claude tools (via canCallTool / mcp) must
+ * wire that separately — task-330a defines the contract; tool-binding
+ * lands in 330d alongside the role-state persistence layer.
+ *
+ * Red lines (per PM dispatch):
+ *   - Do not mutate routing protocol shape (.routes / displayBody).
+ *   - Do not break task-319/328 (parser tests stay green).
+ *   - Old session replay must keep working — we only add new keys to
+ *     session.roleStates[role], never remove.
+ */
+
+import { sendCrewMessage, sendStatusUpdate } from './ui-messages.js';
+import { updateKanban, appendChangelog, updateFeatureIndex, isValidTaskId } from './task-files.js';
+
+/** Valid standby reasons — extend with care; consumers may grep for these. */
+export const STANDBY_REASONS = Object.freeze([
+  'task_closed', 'awaiting_input', 'manual', 'idle', 'paused',
+]);
+
+/**
+ * Mark a task as complete on the kanban + broadcast a status card.
+ *
+ * Mirrors the side-effects that role-output.js performs when it detects a
+ * completed TASKS block, so the two paths converge on the same kanban
+ * state regardless of which one fires.
+ *
+ * @param {object} session
+ * @param {{ taskId: string, summary?: string, fromRole?: string }} params
+ * @returns {Promise<{ ok: boolean, taskId: string, reason?: string }>}
+ */
+export async function taskClose(session, { taskId, summary, fromRole }) {
+  if (!session) {
+    return { ok: false, taskId: taskId || null, reason: 'no_session' };
+  }
+  if (!taskId || !isValidTaskId(taskId)) {
+    return { ok: false, taskId: taskId || null, reason: 'invalid_task_id' };
+  }
+
+  // Mark in the in-memory completion set so future kanban rebuilds keep it.
+  if (!session._completedTaskIds) session._completedTaskIds = new Set();
+  const wasAlreadyCompleted = session._completedTaskIds.has(taskId);
+  session._completedTaskIds.add(taskId);
+
+  const feature = session.features?.get(taskId);
+  const taskTitle = feature?.taskTitle || taskId;
+  const cleanSummary = (summary && String(summary).trim()) || '已完成';
+
+  // Persist to the kanban file (best-effort; warns on failure).
+  try {
+    await updateKanban(session, { taskId, completed: true, summary: cleanSummary });
+  } catch (e) {
+    console.warn(`[Crew] taskClose: updateKanban failed for ${taskId}:`, e.message);
+  }
+
+  // Append to features index + changelog only on first close (idempotent).
+  if (!wasAlreadyCompleted) {
+    updateFeatureIndex(session)
+      .catch(e => console.warn('[Crew] taskClose: updateFeatureIndex failed:', e.message));
+    appendChangelog(session, taskId, taskTitle)
+      .catch(e => console.warn(`[Crew] taskClose: appendChangelog failed for ${taskId}:`, e.message));
+  }
+
+  // Broadcast status card so the UI reflects the close immediately.
+  try {
+    sendCrewMessage({
+      type: 'crew_task_closed',
+      sessionId: session.id,
+      taskId,
+      taskTitle,
+      summary: cleanSummary,
+      fromRole: fromRole || null,
+      timestamp: Date.now(),
+    });
+    sendStatusUpdate(session);
+  } catch (e) {
+    console.warn(`[Crew] taskClose: broadcast failed for ${taskId}:`, e.message);
+  }
+
+  return { ok: true, taskId };
+}
+
+/**
+ * Flip a role into 'standby' (in-memory) and broadcast.
+ *
+ * 330a defines the contract; 330d wires the .crew/context/role-states.json
+ * persistence. We DO mutate `session.roleStates[role].standby` here so the
+ * UI / status pipeline can reflect the change immediately, and 330d can
+ * snapshot it on the next debounced save.
+ *
+ * @param {object} session
+ * @param {{ role: string, reason?: string, fromRole?: string }} params
+ * @returns {{ ok: boolean, role: string, reason?: string }}
+ */
+export function roleStandby(session, { role, reason, fromRole }) {
+  if (!session) {
+    return { ok: false, role: role || null, reason: 'no_session' };
+  }
+  if (!role || typeof role !== 'string') {
+    return { ok: false, role: role || null, reason: 'invalid_role' };
+  }
+  if (!session.roles || !session.roles.has(role)) {
+    return { ok: false, role, reason: 'unknown_role' };
+  }
+
+  const normalizedReason = reason && STANDBY_REASONS.includes(reason)
+    ? reason
+    : 'manual';
+
+  // Ensure the roleState bucket exists (cold-start safe).
+  let roleState = session.roleStates?.get?.(role);
+  if (!roleState) {
+    roleState = {};
+    session.roleStates?.set?.(role, roleState);
+  }
+  // New keys only — never delete legacy fields (replay safety).
+  roleState.standby = {
+    reason: normalizedReason,
+    since: Date.now(),
+    setBy: fromRole || null,
+  };
+
+  try {
+    sendCrewMessage({
+      type: 'crew_role_standby',
+      sessionId: session.id,
+      role,
+      reason: normalizedReason,
+      fromRole: fromRole || null,
+      timestamp: Date.now(),
+    });
+    sendStatusUpdate(session);
+  } catch (e) {
+    console.warn(`[Crew] roleStandby: broadcast failed for ${role}:`, e.message);
+  }
+
+  return { ok: true, role, reason: normalizedReason };
+}

package/crew/context-loader.js

@@ -0,0 +1,171 @@
+/**
+ * Crew Context Loader — detect and parse .crew/ directory structure.
+ *
+ * Reads .crew/CLAUDE.md, session.json, per-role CLAUDE.md files,
+ * kanban, and feature files. Used by the frontend to detect whether
+ * a project has a Crew setup and display role metadata.
+ */
+
+import { join } from 'path';
+import { readFileSync, existsSync, readdirSync } from 'fs';
+import ctx from '../context.js';
+
+const MAX_CLAUDE_MD_LEN = 8192;
+
+/**
+ * Read a file, returning null on any error.
+ * @param {string} filePath
+ * @returns {string|null}
+ */
+function readFileOrNull(filePath) {
+  try {
+    if (!existsSync(filePath)) return null;
+    return readFileSync(filePath, 'utf-8');
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Deduplicate Crew roles by roleType.
+ * Crew may have dev-1, dev-2, dev-3 — collapse to a single "dev" entry.
+ * Attaches per-role CLAUDE.md content.
+ */
+function deduplicateRoles(sessionRoles, roleClaudes) {
+  const byType = new Map();
+  const merged = [];
+
+  for (const r of sessionRoles) {
+    const type = r.roleType || r.name;
+    const claudeMd = roleClaudes[r.name] || '';
+
+    if (byType.has(type)) continue;
+    byType.set(type, true);
+
+    const name = type;
+    let displayName = r.displayName || name;
+    displayName = displayName.replace(/-\d+$/, '');
+
+    merged.push({
+      name,
+      displayName,
+      icon: r.icon || '',
+      description: r.description || '',
+      claudeMd: claudeMd.substring(0, MAX_CLAUDE_MD_LEN),
+      roleType: type,
+      isDecisionMaker: !!r.isDecisionMaker,
+    });
+  }
+
+  return merged;
+}
+
+/**
+ * Load .crew context from a project directory.
+ * Returns null if .crew/ doesn't exist.
+ */
+export function loadCrewContext(projectDir) {
+  const crewDir = join(projectDir, '.crew');
+  if (!existsSync(crewDir)) return null;
+
+  // 1. Shared CLAUDE.md
+  const sharedClaudeMd = readFileOrNull(join(crewDir, 'CLAUDE.md')) || '';
+
+  // 2. session.json → roles, teamType, language, features
+  let sessionRoles = [];
+  let teamType = 'dev';
+  let language = 'zh-CN';
+  let sessionFeatures = [];
+  const sessionPath = join(crewDir, 'session.json');
+  const sessionJson = readFileOrNull(sessionPath);
+  if (sessionJson) {
+    try {
+      const session = JSON.parse(sessionJson);
+      if (Array.isArray(session.roles)) sessionRoles = session.roles;
+      if (session.teamType) teamType = session.teamType;
+      if (session.language) language = session.language;
+      if (Array.isArray(session.features)) sessionFeatures = session.features;
+    } catch {
+      // Invalid JSON — ignore
+    }
+  }
+
+  // 3. Per-role CLAUDE.md from .crew/roles/*/CLAUDE.md
+  const roleClaudes = {};
+  const rolesDir = join(crewDir, 'roles');
+  if (existsSync(rolesDir)) {
+    try {
+      const roleDirs = readdirSync(rolesDir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name);
+      for (const dirName of roleDirs) {
+        const md = readFileOrNull(join(rolesDir, dirName, 'CLAUDE.md'));
+        if (md) roleClaudes[dirName] = md;
+      }
+    } catch {
+      // Permission error or similar — ignore
+    }
+  }
+
+  // 4. Merge roles: deduplicate by roleType, attach claudeMd
+  const roles = deduplicateRoles(sessionRoles, roleClaudes);
+
+  // 5. Kanban
+  const kanban = readFileOrNull(join(crewDir, 'context', 'kanban.md')) || '';
+
+  // 6. Feature files from context/features/*.md
+  const features = [];
+  const featuresDir = join(crewDir, 'context', 'features');
+  if (existsSync(featuresDir)) {
+    try {
+      const files = readdirSync(featuresDir)
+        .filter(f => f.endsWith('.md') && f !== 'index.md')
+        .sort();
+      for (const f of files) {
+        const content = readFileOrNull(join(featuresDir, f));
+        if (content) {
+          features.push({ name: f.replace('.md', ''), content });
+        }
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  return { sharedClaudeMd, roles, kanban, features, teamType, language, sessionFeatures };
+}
+
+/**
+ * Handle check_crew_context message — check if a project has .crew/ setup
+ * and return role metadata for the frontend.
+ */
+export function handleCheckCrewContext(msg) {
+  const { projectDir, requestId } = msg;
+  if (!projectDir) {
+    ctx.sendToServer({ type: 'crew_context_result', requestId, found: false });
+    return;
+  }
+  const crewContext = loadCrewContext(projectDir);
+  if (!crewContext) {
+    ctx.sendToServer({ type: 'crew_context_result', requestId, found: false });
+    return;
+  }
+  // Return a safe subset for the frontend (no full claudeMd content, just metadata)
+  ctx.sendToServer({
+    type: 'crew_context_result',
+    requestId,
+    found: true,
+    roles: crewContext.roles.map(r => ({
+      name: r.name,
+      displayName: r.displayName,
+      icon: r.icon,
+      description: r.description,
+      roleType: r.roleType,
+      isDecisionMaker: r.isDecisionMaker,
+      hasClaudeMd: !!(r.claudeMd && r.claudeMd.length > 0),
+    })),
+    teamType: crewContext.teamType,
+    language: crewContext.language,
+    featureCount: crewContext.features.length,
+  });
+}