@yeaft/webchat-agent 0.1.75 → 0.1.76

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.75",
+  "version": "0.1.76",
   "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;
+}