@yeaft/webchat-agent 0.1.75 → 0.1.77

package/claude.js

@@ -8,7 +8,9 @@ import {
   detectRoleSignal,
   processRolePlayRoutes,
   buildRouteEventMessage,
-  getRolePlayRouteState
+  getRolePlayRouteState,
+  refreshCrewContext,
+  writeBackRouteContext
 } from './roleplay.js';
 
 /**
@@ -447,6 +449,12 @@ async function processClaudeOutput(conversationId, claudeQuery, state) {
               ctx.sendToServer(routeEvent);
             }
 
+            // ★ Write-back: persist route task info to .crew/context/features
+            const taskRoutes = routes.filter(r => r.taskId && r.summary);
+            if (taskRoutes.length > 0 && state.workDir) {
+              writeBackRouteContext(state.workDir, taskRoutes, rpSession.currentRole || 'unknown', rpSession);
+            }
+
             // Send route state update
             const routeState = getRolePlayRouteState(conversationId);
             if (routeState) {

package/conversation.js

@@ -2,7 +2,7 @@ import ctx from './context.js';
 import { loadSessionHistory } from './history.js';
 import { startClaudeQuery } from './claude.js';
 import { crewSessions, loadCrewIndex } from './crew.js';
-import { rolePlaySessions, saveRolePlayIndex, removeRolePlaySession, loadRolePlayIndex, validateRolePlayConfig, initRolePlayRouteState, loadCrewContext } from './roleplay.js';
+import { rolePlaySessions, saveRolePlayIndex, removeRolePlaySession, loadRolePlayIndex, validateRolePlayConfig, initRolePlayRouteState, loadCrewContext, refreshCrewContext, initCrewContextMtimes } from './roleplay.js';
 
 // Restore persisted roleplay sessions on module load (agent startup)
 loadRolePlayIndex();
@@ -256,10 +256,21 @@ export async function resumeConversation(msg) {
   // Claude 进程会在用户发送第一条消息时启动 (见 handleUserInput)
   // Restore rolePlayConfig from persisted rolePlaySessions if available
   const rolePlayEntry = rolePlaySessions.get(conversationId);
-  const rolePlayConfig = rolePlayEntry
+  let rolePlayConfig = rolePlayEntry
     ? { roles: rolePlayEntry.roles, teamType: rolePlayEntry.teamType, language: rolePlayEntry.language }
     : null;
 
+  // ★ RolePlay resume: refresh .crew context to get latest kanban/features
+  if (rolePlayConfig && rolePlayEntry) {
+    const crewContext = loadCrewContext(effectiveWorkDir);
+    if (crewContext) {
+      rolePlayConfig.crewContext = crewContext;
+      // Initialize mtime snapshot (without re-loading) so subsequent refreshes can detect changes
+      initCrewContextMtimes(effectiveWorkDir, rolePlayEntry);
+      console.log(`[Resume] RolePlay: refreshed .crew context (${crewContext.features.length} features)`);
+    }
+  }
+
   ctx.conversations.set(conversationId, {
     query: null,
     inputStream: null,
@@ -483,6 +494,18 @@ export async function handleUserInput(msg) {
     const resumeSessionId = claudeSessionId || state?.claudeSessionId || null;
     const effectiveWorkDir = workDir || state?.workDir || ctx.CONFIG.workDir;
 
+    // ★ RolePlay: refresh .crew context before starting a new query
+    // so the appendSystemPrompt has the latest kanban/features
+    if (state?.rolePlayConfig) {
+      const rpSession = rolePlaySessions.get(conversationId);
+      if (rpSession) {
+        const refreshed = refreshCrewContext(effectiveWorkDir, rpSession, state);
+        if (refreshed) {
+          console.log(`[SDK] RolePlay: .crew context refreshed before query start`);
+        }
+      }
+    }
+
     console.log(`[SDK] Starting Claude for ${conversationId}, resume: ${resumeSessionId || 'none'}`);
     state = await startClaudeQuery(conversationId, effectiveWorkDir, resumeSessionId);
   }

package/crew/control.js

@@ -66,6 +66,11 @@ export async function handleCrewControl(msg) {
 async function clearSingleRole(session, roleName) {
   const roleState = session.roleStates.get(roleName);
 
+  // P0-1: 清除该角色在 humanMessageQueue 中的待处理消息，防止幽灵 ROUTE 执行
+  if (session.humanMessageQueue.length > 0) {
+    session.humanMessageQueue = session.humanMessageQueue.filter(m => m.target !== roleName);
+  }
+
   if (roleState) {
     // 保存工作摘要到 task file（与 context_exceeded clear 一致）
     if (roleState.accumulatedText) {
@@ -73,9 +78,21 @@ async function clearSingleRole(session, roleName) {
         console.warn(`[Crew] Failed to save work summary for ${roleName}:`, e.message));
     }
 
+    // P1-3: abort 并等待 query iterator 退出，避免 abort+dispatch 竞态
     if (roleState.abortController) {
       roleState.abortController.abort();
     }
+    // 等待 query 完成（iterator 会因 AbortError 退出）
+    if (roleState.query) {
+      try {
+        // Drain the iterator — it will throw AbortError and exit
+        // eslint-disable-next-line no-empty
+        for await (const _ of roleState.query) {}
+      } catch {
+        // Expected: AbortError or other cleanup errors
+      }
+    }
+
     roleState.query = null;
     roleState.inputStream = null;
     roleState.turnActive = false;
@@ -86,6 +103,10 @@ async function clearSingleRole(session, roleName) {
     roleState.lastDispatchFrom = null;
     roleState.lastDispatchTaskId = null;
     roleState.lastDispatchTaskTitle = null;
+    // P0-3: 重置 UI 相关状态，防止显示过时信息
+    roleState.currentTask = null;
+    roleState.currentTool = null;
+    roleState.lastTurnText = '';
   }
 
   await clearRoleSessionId(session.sharedDir, roleName);
@@ -168,12 +189,12 @@ async function resumeSession(session) {
     const pending = session.pendingRoutes.slice();
     session.pendingRoutes = [];
     console.log(`[Crew] Replaying ${pending.length} pending route(s)`);
-    const results = await Promise.allSettled(pending.map(({ fromRole, route }) =>
-      executeRoute(session, fromRole, route)
-    ));
-    for (const r of results) {
-      if (r.status === 'rejected') {
-        console.warn(`[Crew] Pending route replay failed:`, r.reason);
+    // P1-5: 串行执行 pending routes，防止多个 route 指向同一角色时并发 dispatch
+    for (const { fromRole, route } of pending) {
+      try {
+        await executeRoute(session, fromRole, route);
+      } catch (err) {
+        console.warn(`[Crew] Pending route replay failed:`, err);
       }
     }
     return;
@@ -338,6 +359,9 @@ async function stopAll(session) {
  * 清空 session
  */
 async function clearSession(session) {
+  // P1-2: 先重置 _processingHumanQueue，防止后续消息处理被阻塞
+  session._processingHumanQueue = false;
+
   for (const [roleName, roleState] of session.roleStates) {
     if (roleState.abortController) {
       roleState.abortController.abort();
@@ -350,6 +374,7 @@ async function clearSession(session) {
     await clearRoleSessionId(session.sharedDir, roleName);
   }
 
+  // P1-1: humanMessageQueue 在这里清空，确保不会有幽灵消息在 clear 后被处理
   session.messageHistory = [];
   session.uiMessages = [];
   session.humanMessageQueue = [];

package/crew/human-interaction.js

@@ -86,10 +86,31 @@ export async function handleCrewHumanInput(msg) {
           const { createRoleQuery } = await import('./role-query.js');
           roleState = await createRoleQuery(session, target);
         }
-        roleState.inputStream.enqueue({
-          type: 'user',
-          message: { role: 'user', content: message }
-        });
+        // P1-4: 守卫 stream.enqueue
+        try {
+          if (roleState.inputStream && !roleState.inputStream.isDone) {
+            roleState.inputStream.enqueue({
+              type: 'user',
+              message: { role: 'user', content: message }
+            });
+          } else {
+            console.warn(`[Crew] Skill dispatch: stream closed for ${target}, recreating`);
+            const { createRoleQuery } = await import('./role-query.js');
+            roleState = await createRoleQuery(session, target);
+            roleState.inputStream.enqueue({
+              type: 'user',
+              message: { role: 'user', content: message }
+            });
+          }
+        } catch (enqueueErr) {
+          console.error(`[Crew] Skill dispatch enqueue failed for ${target}:`, enqueueErr.message);
+          const { createRoleQuery } = await import('./role-query.js');
+          roleState = await createRoleQuery(session, target);
+          roleState.inputStream.enqueue({
+            type: 'user',
+            message: { role: 'user', content: message }
+          });
+        }
         sendStatusUpdate(session);
         console.log(`[Crew] Skill command dispatched to ${target}: ${message}`);
         return;

package/crew/role-query.js

@@ -84,10 +84,48 @@ export function classifyRoleError(error) {
 // Role Query Management
 // =====================================================================
 
+// P1-6: Per-role mutex to prevent concurrent createRoleQuery calls creating orphan processes
+const _roleQueryLocks = new Map();
+
 /**
  * 为角色创建持久 query 实例
  */
 export async function createRoleQuery(session, roleName) {
+  const lockKey = `${session.id}:${roleName}`;
+
+  // P1-6: 如果该角色已有 pending 的 createRoleQuery，等待它完成
+  if (_roleQueryLocks.has(lockKey)) {
+    console.log(`[Crew] Waiting for existing createRoleQuery lock on ${roleName}`);
+    try {
+      await _roleQueryLocks.get(lockKey);
+    } catch {
+      // Previous attempt failed, proceed with new creation
+    }
+    // 锁释放后，检查是否已经有可用的 query
+    const existing = session.roleStates.get(roleName);
+    if (existing?.query && existing?.inputStream && !existing.inputStream.isDone) {
+      console.log(`[Crew] Reusing existing query for ${roleName} after lock release`);
+      return existing;
+    }
+  }
+
+  const promise = _createRoleQueryInner(session, roleName);
+  _roleQueryLocks.set(lockKey, promise);
+  try {
+    const result = await promise;
+    return result;
+  } finally {
+    // 只删除自己的 lock（如果后续调用覆盖了，不误删）
+    if (_roleQueryLocks.get(lockKey) === promise) {
+      _roleQueryLocks.delete(lockKey);
+    }
+  }
+}
+
+/**
+ * createRoleQuery 内部实现
+ */
+async function _createRoleQueryInner(session, roleName) {
   const role = session.roles.get(roleName);
   if (!role) throw new Error(`Role not found: ${roleName}`);
 

package/crew/routing.js

@@ -227,17 +227,48 @@ export async function dispatchToRole(session, roleName, content, fromSource, tas
     roleState = await createRoleQuery(session, roleName);
   }
 
-  // 发送
+  // P1-4: 守卫 stream.enqueue — stream 可能已被 abort 关闭
   roleState.lastDispatchContent = content;
   roleState.lastDispatchFrom = fromSource;
   roleState.lastDispatchTaskId = taskId || null;
   roleState.lastDispatchTaskTitle = taskTitle || null;
   roleState.turnActive = true;
   roleState.accumulatedText = '';
-  roleState.inputStream.enqueue({
-    type: 'user',
-    message: { role: 'user', content }
-  });
+  try {
+    if (roleState.inputStream && !roleState.inputStream.isDone) {
+      roleState.inputStream.enqueue({
+        type: 'user',
+        message: { role: 'user', content }
+      });
+    } else {
+      console.warn(`[Crew] Cannot enqueue to ${roleName}: stream closed or missing, recreating`);
+      roleState = await createRoleQuery(session, roleName);
+      roleState.lastDispatchContent = content;
+      roleState.lastDispatchFrom = fromSource;
+      roleState.lastDispatchTaskId = taskId || null;
+      roleState.lastDispatchTaskTitle = taskTitle || null;
+      roleState.turnActive = true;
+      roleState.accumulatedText = '';
+      roleState.inputStream.enqueue({
+        type: 'user',
+        message: { role: 'user', content }
+      });
+    }
+  } catch (enqueueErr) {
+    console.error(`[Crew] Failed to enqueue to ${roleName}:`, enqueueErr.message);
+    // Recreate query and retry once
+    roleState = await createRoleQuery(session, roleName);
+    roleState.lastDispatchContent = content;
+    roleState.lastDispatchFrom = fromSource;
+    roleState.lastDispatchTaskId = taskId || null;
+    roleState.lastDispatchTaskTitle = taskTitle || null;
+    roleState.turnActive = true;
+    roleState.accumulatedText = '';
+    roleState.inputStream.enqueue({
+      type: 'user',
+      message: { role: 'user', content }
+    });
+  }
 
   sendStatusUpdate(session);
   console.log(`[Crew] Dispatched to ${roleName} from ${fromSource}${taskId ? ` (task: ${taskId})` : ''}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.75",
+  "version": "0.1.77",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/roleplay.js

@@ -9,7 +9,8 @@
 
 import { join } from 'path';
 import { homedir } from 'os';
-import { readFileSync, writeFileSync, existsSync, renameSync, readdirSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync, renameSync, readdirSync, statSync } from 'fs';
+import { promises as fsp } from 'fs';
 import { parseRoutes } from './crew/routing.js';
 
 const ROLEPLAY_INDEX_PATH = join(homedir(), '.claude', 'roleplay-sessions.json');
@@ -26,8 +27,8 @@ export const rolePlaySessions = new Map();
 export function saveRolePlayIndex() {
   const data = [];
   for (const [id, session] of rolePlaySessions) {
-    // Only persist core fields, skip runtime route state
-    const { _routeInitialized, currentRole, features, round, roleStates, waitingHuman, waitingHumanContext, ...core } = session;
+    // Only persist core fields, skip runtime route state and mtime snapshots
+    const { _routeInitialized, _crewContextMtimes, currentRole, features, round, roleStates, waitingHuman, waitingHumanContext, ...core } = session;
     data.push({ id, ...core });
   }
   try {
@@ -218,7 +219,7 @@ function deduplicateRoles(sessionRoles, roleClaudes) {
 const ALLOWED_TEAM_TYPES = ['dev', 'writing', 'trading', 'video', 'custom'];
 const MAX_ROLE_NAME_LEN = 64;
 const MAX_DISPLAY_NAME_LEN = 128;
-const MAX_CLAUDE_MD_LEN = 4096;
+const MAX_CLAUDE_MD_LEN = 8192;
 const MAX_ROLES = 10;
 
 /**
@@ -716,3 +717,227 @@ function buildCrewContextBlock(crewContext, isZh) {
 
   return sections.join('\n\n');
 }
+
+// ---------------------------------------------------------------------------
+// .crew context refresh (mtime-based change detection)
+// ---------------------------------------------------------------------------
+
+/**
+ * Get mtime of a file, or 0 if it doesn't exist.
+ * @param {string} filePath
+ * @returns {number} mtime in ms
+ */
+function getMtimeMs(filePath) {
+  try {
+    return statSync(filePath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Collect mtimes for all .crew context files that matter for RolePlay.
+ * Returns a map of { relativePath → mtimeMs }.
+ *
+ * @param {string} projectDir
+ * @returns {Map<string, number>}
+ */
+function collectCrewContextMtimes(projectDir) {
+  const crewDir = join(projectDir, '.crew');
+  const mtimes = new Map();
+
+  // Shared CLAUDE.md
+  mtimes.set('CLAUDE.md', getMtimeMs(join(crewDir, 'CLAUDE.md')));
+
+  // context/kanban.md
+  mtimes.set('context/kanban.md', getMtimeMs(join(crewDir, 'context', 'kanban.md')));
+
+  // context/features/*.md
+  const featuresDir = join(crewDir, 'context', 'features');
+  if (existsSync(featuresDir)) {
+    try {
+      const files = readdirSync(featuresDir).filter(f => f.endsWith('.md') && f !== 'index.md');
+      for (const f of files) {
+        mtimes.set(`context/features/${f}`, getMtimeMs(join(featuresDir, f)));
+      }
+    } catch { /* ignore */ }
+  }
+
+  // session.json (roles may change)
+  mtimes.set('session.json', getMtimeMs(join(crewDir, 'session.json')));
+
+  return mtimes;
+}
+
+/**
+ * Check if .crew context has changed since last snapshot.
+ *
+ * @param {Map<string, number>} oldMtimes - previous mtime snapshot
+ * @param {Map<string, number>} newMtimes - current mtime snapshot
+ * @returns {boolean} true if any file has been added, removed, or modified
+ */
+function hasCrewContextChanged(oldMtimes, newMtimes) {
+  if (!oldMtimes) return true; // first check → always refresh
+
+  // Defensive: if oldMtimes was deserialized from JSON (plain object, not Map),
+  // treat as stale and force refresh
+  if (!(oldMtimes instanceof Map)) return true;
+
+  // Check for new or modified files
+  for (const [path, mtime] of newMtimes) {
+    if (!oldMtimes.has(path) || oldMtimes.get(path) !== mtime) return true;
+  }
+
+  // Check for deleted files
+  for (const path of oldMtimes.keys()) {
+    if (!newMtimes.has(path)) return true;
+  }
+
+  return false;
+}
+
+/**
+ * Initialize the mtime snapshot for a RolePlay session without reloading context.
+ * Use this when the caller has already loaded crewContext (e.g. resume path)
+ * to avoid a redundant disk read.
+ *
+ * @param {string} projectDir - absolute path to project root
+ * @param {object} rpSession - rolePlaySessions entry
+ */
+export function initCrewContextMtimes(projectDir, rpSession) {
+  if (!projectDir || !existsSync(join(projectDir, '.crew'))) return;
+  rpSession._crewContextMtimes = collectCrewContextMtimes(projectDir);
+}
+
+/**
+ * Refresh .crew context for a RolePlay session if files have changed.
+ * Updates the session's crewContext and returns true if refreshed.
+ *
+ * Call this before building the system prompt (on resume, or before each turn).
+ *
+ * @param {string} projectDir - absolute path to project root
+ * @param {object} rpSession - rolePlaySessions entry
+ * @param {object} convState - ctx.conversations entry (has rolePlayConfig)
+ * @returns {boolean} true if context was refreshed
+ */
+export function refreshCrewContext(projectDir, rpSession, convState) {
+  if (!projectDir || !existsSync(join(projectDir, '.crew'))) return false;
+
+  const newMtimes = collectCrewContextMtimes(projectDir);
+
+  // Compare with stored snapshot
+  if (!hasCrewContextChanged(rpSession._crewContextMtimes, newMtimes)) {
+    return false; // no change
+  }
+
+  // Reload
+  const crewContext = loadCrewContext(projectDir);
+  if (!crewContext) return false;
+
+  // Update session and convState
+  rpSession._crewContextMtimes = newMtimes;
+
+  if (convState && convState.rolePlayConfig) {
+    convState.rolePlayConfig.crewContext = crewContext;
+  }
+
+  console.log(`[RolePlay] Crew context refreshed from ${projectDir} (${crewContext.features.length} features, kanban: ${crewContext.kanban ? 'yes' : 'no'})`);
+  return true;
+}
+
+// ---------------------------------------------------------------------------
+// .crew context write-back (RolePlay → .crew/context)
+// ---------------------------------------------------------------------------
+
+// Write lock for atomic write-back
+let _writeBackLock = Promise.resolve();
+
+/**
+ * Atomic write: write to temp file then rename.
+ * @param {string} filePath
+ * @param {string} content
+ */
+async function atomicWrite(filePath, content) {
+  const tmpPath = filePath + '.tmp.' + Date.now();
+  try {
+    await fsp.writeFile(tmpPath, content);
+    await fsp.rename(tmpPath, filePath);
+  } catch (e) {
+    // Clean up temp file on failure
+    try { await fsp.unlink(tmpPath); } catch { /* ignore */ }
+    throw e;
+  }
+}
+
+/**
+ * Write back RolePlay route output to .crew/context files.
+ * Called after processRolePlayRoutes detects ROUTE blocks with task info.
+ *
+ * - Creates/updates context/features/{taskId}.md with route summary
+ * - Serialized via write lock to prevent concurrent corruption
+ *
+ * NOTE: The atomic write (tmp→rename) prevents partial writes within this
+ * process, and the serial lock prevents intra-process races. However, if a
+ * Crew session in a separate process writes the same file concurrently,
+ * a TOCTOU race is possible (read-then-write is not locked across processes).
+ * In practice this is acceptable: Crew and RolePlay rarely write the same
+ * task file simultaneously, and the worst case is a lost append (not corruption).
+ *
+ * @param {string} projectDir - absolute path to project root
+ * @param {Array<{to: string, summary: string, taskId?: string, taskTitle?: string}>} routes
+ * @param {string} fromRole - name of the role that produced the output
+ * @param {object} rpSession - rolePlaySessions entry
+ */
+export function writeBackRouteContext(projectDir, routes, fromRole, rpSession) {
+  if (!projectDir || !routes || routes.length === 0) return;
+
+  const crewDir = join(projectDir, '.crew');
+  if (!existsSync(crewDir)) return;
+
+  const doWriteBack = async () => {
+    const featuresDir = join(crewDir, 'context', 'features');
+
+    for (const route of routes) {
+      const { taskId, taskTitle, summary, to } = route;
+      if (!taskId || !summary) continue;
+
+      // ★ Sanitize taskId: only allow alphanumeric, hyphens, underscores
+      // Prevents path traversal (e.g. "../" in taskId from Claude output)
+      if (!/^[a-zA-Z0-9_-]+$/.test(taskId)) {
+        console.warn(`[RolePlay] Write-back rejected: invalid taskId "${taskId}"`);
+        continue;
+      }
+
+      try {
+        await fsp.mkdir(featuresDir, { recursive: true });
+        const filePath = join(featuresDir, `${taskId}.md`);
+
+        let content;
+        try {
+          content = await fsp.readFile(filePath, 'utf-8');
+        } catch {
+          // File doesn't exist — create it
+          const isZh = rpSession.language === 'zh-CN';
+          content = `# ${isZh ? 'Feature' : 'Feature'}: ${taskTitle || taskId}\n- task-id: ${taskId}\n\n## ${isZh ? '工作记录' : 'Work Record'}\n`;
+        }
+
+        // Append the route record
+        const fromRoleConfig = rpSession.roles?.find(r => r.name === fromRole);
+        const fromLabel = fromRoleConfig
+          ? (fromRoleConfig.icon ? `${fromRoleConfig.icon} ${fromRoleConfig.displayName}` : fromRoleConfig.displayName)
+          : fromRole;
+        const now = new Date().toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' });
+        const record = `\n### ${fromLabel} → ${to} - ${now}\n${summary}\n`;
+
+        await atomicWrite(filePath, content + record);
+        console.log(`[RolePlay] Write-back: task ${taskId} updated (${fromRole} → ${to})`);
+      } catch (e) {
+        console.warn(`[RolePlay] Write-back failed for ${taskId}:`, e.message);
+      }
+    }
+  };
+
+  // Serialize write-backs
+  _writeBackLock = _writeBackLock.then(doWriteBack, doWriteBack);
+  return _writeBackLock;
+}