@yeaft/webchat-agent 0.1.68 → 0.1.70

package/claude.js

@@ -408,7 +408,7 @@ async function processClaudeOutput(conversationId, claudeQuery, state) {
 
         // 计算上下文使用百分比
         const inputTokens = message.usage?.input_tokens || 0;
-        const maxContextTokens = 128000; // API max_prompt_tokens 限制
+        const maxContextTokens = ctx.CONFIG?.maxContextTokens || 128000;
         if (inputTokens > 0) {
           ctx.sendToServer({
             type: 'context_usage',
@@ -497,6 +497,35 @@ async function processClaudeOutput(conversationId, claudeQuery, state) {
 
             console.log(`[RolePlay] Auto-continuing to role: ${to}`);
 
+            // ★ Pre-send compact check for RolePlay auto-continue
+            const rpAutoCompactThreshold = ctx.CONFIG?.autoCompactThreshold || 110000;
+            const rpEstimatedNewTokens = Math.ceil(prompt.length / 3);
+            const rpEstimatedTotal = inputTokens + rpEstimatedNewTokens;
+
+            if (rpEstimatedTotal > rpAutoCompactThreshold) {
+              console.log(`[RolePlay] Pre-send compact: estimated ${rpEstimatedTotal} tokens (last: ${inputTokens} + new: ~${rpEstimatedNewTokens}) exceeds threshold ${rpAutoCompactThreshold}`);
+              ctx.sendToServer({
+                type: 'compact_status',
+                conversationId,
+                status: 'compacting',
+                message: `Auto-compacting before RolePlay continue: estimated ${rpEstimatedTotal} tokens (threshold: ${rpAutoCompactThreshold})`
+              });
+              // Store pending message and compact first
+              const userMessage = {
+                type: 'user',
+                message: { role: 'user', content: prompt }
+              };
+              state._pendingUserMessage = userMessage;
+              state.turnActive = true;
+              state.turnResultReceived = false;
+              state.inputStream.enqueue({
+                type: 'user',
+                message: { role: 'user', content: '/compact' }
+              });
+              sendConversationList();
+              break;
+            }
+
             // Re-activate the turn
             state.turnActive = true;
             state.turnResultReceived = false;
@@ -531,6 +560,18 @@ async function processClaudeOutput(conversationId, claudeQuery, state) {
           workDir: state.workDir
         });
         sendConversationList();
+
+        // ★ Send pending user message after compact completes
+        if (state._pendingUserMessage && state.inputStream) {
+          const pendingMsg = state._pendingUserMessage;
+          state._pendingUserMessage = null;
+          console.log(`[${conversationId}] Sending pending message after compact`);
+          state.turnActive = true;
+          state.turnResultReceived = false;
+          sendOutput(conversationId, pendingMsg);
+          state.inputStream.enqueue(pendingMsg);
+          sendConversationList();
+        }
         continue;
       }
 

package/conversation.js

@@ -515,6 +515,34 @@ export async function handleUserInput(msg) {
   };
 
   console.log(`[${conversationId}] Sending: ${prompt.substring(0, 100)}...`);
+
+  // ★ Pre-send compact check: estimate total tokens and compact before sending if needed
+  const autoCompactThreshold = ctx.CONFIG?.autoCompactThreshold || 110000;
+  const lastInputTokens = state.lastResultInputTokens || 0;
+  const estimatedNewTokens = Math.ceil(effectivePrompt.length / 3); // conservative: ~3 chars per token
+  const estimatedTotal = lastInputTokens + estimatedNewTokens;
+
+  if (estimatedTotal > autoCompactThreshold && state.inputStream) {
+    console.log(`[${conversationId}] Pre-send compact: estimated ${estimatedTotal} tokens (last: ${lastInputTokens} + new: ~${estimatedNewTokens}) exceeds threshold ${autoCompactThreshold}`);
+    ctx.sendToServer({
+      type: 'compact_status',
+      conversationId,
+      status: 'compacting',
+      message: `Auto-compacting before send: estimated ${estimatedTotal} tokens (threshold: ${autoCompactThreshold})`
+    });
+    // Send /compact first, then the user message will be sent after compact completes
+    // by storing it as a pending message
+    state._pendingUserMessage = userMessage;
+    state.turnActive = true;
+    state.turnResultReceived = false;
+    sendConversationList();
+    state.inputStream.enqueue({
+      type: 'user',
+      message: { role: 'user', content: '/compact' }
+    });
+    return;
+  }
+
   state.turnActive = true;
   state.turnResultReceived = false; // 重置 per-turn 去重标志
   sendConversationList(); // 在 turnActive=true 后通知 server，确保 processing 状态正确

package/crew/role-output.js

@@ -6,10 +6,10 @@ import { sendCrewMessage, sendCrewOutput, sendStatusUpdate, endRoleStreaming } f
 import { saveRoleSessionId, clearRoleSessionId, classifyRoleError, createRoleQuery } from './role-query.js';
 import { parseRoutes, executeRoute, dispatchToRole } from './routing.js';
 import { parseCompletedTasks, updateFeatureIndex, appendChangelog, saveRoleWorkSummary, updateKanban } from './task-files.js';
+import ctx from '../context.js';
 
-// Context 使用率阈值常量
-const MAX_CONTEXT = 128000;       // API max_prompt_tokens 限制
-const CLEAR_THRESHOLD = 0.85;     // 85% → 直接 clear + rebuild（不再走 compact）
+// Context 使用率常量（运行时从 ctx.CONFIG 读取）
+const getMaxContext = () => ctx.CONFIG?.maxContextTokens || 128000;
 
 /**
  * 处理角色的流式输出
@@ -99,14 +99,11 @@ export async function processRoleOutput(session, roleName, roleQuery, roleState)
             sessionId: session.id,
             role: roleName,
             inputTokens,
-            maxTokens: MAX_CONTEXT,
-            percentage: Math.min(100, Math.round((inputTokens / MAX_CONTEXT) * 100))
+            maxTokens: getMaxContext(),
+            percentage: Math.min(100, Math.round((inputTokens / getMaxContext()) * 100))
           });
         }
 
-        const contextPercentage = inputTokens / MAX_CONTEXT;
-        const needClear = contextPercentage >= CLEAR_THRESHOLD;
-
         // 解析路由
         const routes = parseRoutes(roleState.accumulatedText);
 
@@ -136,8 +133,8 @@ export async function processRoleOutput(session, roleName, roleQuery, roleState)
           }
         }
 
-        // 保存 accumulatedText 供后续 saveRoleWorkSummary 使用（清空前）
-        const turnText = roleState.accumulatedText;
+        // 保存本 turn 文本（供 routing.js 预检时 saveRoleWorkSummary 使用）
+        roleState.lastTurnText = roleState.accumulatedText;
         roleState.accumulatedText = '';
         roleState.turnActive = false;
 
@@ -149,57 +146,7 @@ export async function processRoleOutput(session, roleName, roleQuery, roleState)
 
         sendStatusUpdate(session);
 
-        // Context 超限：保存工作摘要后 clear + rebuild
-        if (needClear) {
-          console.log(`[Crew] ${roleName} context at ${Math.round(contextPercentage * 100)}%, clearing and rebuilding`);
-
-          // 保存工作摘要到 feature 文件
-          await saveRoleWorkSummary(session, roleName, turnText).catch(e =>
-            console.warn(`[Crew] Failed to save work summary for ${roleName}:`, e.message));
-
-          // Clear 角色
-          await clearRoleSessionId(session.sharedDir, roleName);
-          roleState.claudeSessionId = null;
-
-          if (roleState.abortController) roleState.abortController.abort();
-          roleState.query = null;
-          roleState.inputStream = null;
-
-          sendCrewMessage({
-            type: 'crew_role_cleared',
-            sessionId: session.id,
-            role: roleName,
-            contextPercentage: Math.round(contextPercentage * 100),
-            reason: 'context_limit'
-          });
-
-          // 继承 task 到路由（如有）
-          const currentTask = roleState.currentTask;
-          if (routes.length > 0) {
-            for (const route of routes) {
-              if (!route.taskId && currentTask) {
-                route.taskId = currentTask.taskId;
-                route.taskTitle = currentTask.taskTitle;
-              }
-            }
-          }
-
-          // 执行路由
-          if (routes.length > 0) {
-            session.round++;
-            const results = await Promise.allSettled(routes.map(route =>
-              executeRoute(session, roleName, route)
-            ));
-            for (const r of results) {
-              if (r.status === 'rejected') {
-                console.warn(`[Crew] Route execution failed:`, r.reason);
-              }
-            }
-          }
-          return; // query 已清空，退出
-        }
-
-        // 执行路由（无需 clear 时）
+        // 执行路由
         if (routes.length > 0) {
           session.round++;
 

package/crew/routing.js

@@ -4,8 +4,9 @@
  */
 import { join } from 'path';
 import { sendCrewMessage, sendCrewOutput, sendStatusUpdate } from './ui-messages.js';
-import { ensureTaskFile, appendTaskRecord, readTaskFile, updateKanban, readKanban } from './task-files.js';
-import { createRoleQuery } from './role-query.js';
+import { ensureTaskFile, appendTaskRecord, readTaskFile, updateKanban, readKanban, saveRoleWorkSummary } from './task-files.js';
+import { createRoleQuery, clearRoleSessionId } from './role-query.js';
+import ctx from '../context.js';
 
 /** Format role label */
 function roleLabel(r) {
@@ -193,6 +194,39 @@ export async function dispatchToRole(session, roleName, content, fromSource, tas
     timestamp: Date.now()
   });
 
+  // ★ Pre-send compact check: estimate total tokens and clear+rebuild if needed
+  const autoCompactThreshold = ctx.CONFIG?.autoCompactThreshold || 110000;
+  const lastInputTokens = roleState.lastInputTokens || 0;
+  const estimatedNewTokens = Math.ceil((typeof content === 'string' ? content.length : 0) / 3);
+  const estimatedTotal = lastInputTokens + estimatedNewTokens;
+
+  if (lastInputTokens > 0 && estimatedTotal > autoCompactThreshold) {
+    console.log(`[Crew] Pre-send compact for ${roleName}: estimated ${estimatedTotal} tokens (last: ${lastInputTokens} + new: ~${estimatedNewTokens}) exceeds threshold ${autoCompactThreshold}`);
+
+    // Save work summary before clearing (use lastTurnText since accumulatedText is cleared after result)
+    await saveRoleWorkSummary(session, roleName, roleState.lastTurnText || roleState.accumulatedText || '').catch(e =>
+      console.warn(`[Crew] Failed to save work summary for ${roleName}:`, e.message));
+
+    // Clear role session and rebuild
+    await clearRoleSessionId(session.sharedDir, roleName);
+    roleState.claudeSessionId = null;
+
+    if (roleState.abortController) roleState.abortController.abort();
+    roleState.query = null;
+    roleState.inputStream = null;
+
+    sendCrewMessage({
+      type: 'crew_role_cleared',
+      sessionId: session.id,
+      role: roleName,
+      contextPercentage: Math.round((lastInputTokens / (ctx.CONFIG?.maxContextTokens || 128000)) * 100),
+      reason: 'pre_send_compact'
+    });
+
+    // Recreate the query (fresh Claude process)
+    roleState = await createRoleQuery(session, roleName);
+  }
+
   // 发送
   roleState.lastDispatchContent = content;
   roleState.lastDispatchFrom = fromSource;

package/index.js

@@ -74,7 +74,11 @@ const CONFIG = {
     return raw.split(',').map(s => s.trim()).filter(Boolean);
   })(),
   // disallowedTools 会在 loadMcpServers() 中计算
-  disallowedTools: []
+  disallowedTools: [],
+  // 最大上下文 tokens（用于百分比计算的分母）
+  maxContextTokens: parseInt(process.env.MAX_CONTEXT_TOKENS || fileConfig.maxContextTokens, 10) || 128000,
+  // Auto-compact 阈值（tokens）：context 超过此值时自动触发 compact
+  autoCompactThreshold: parseInt(process.env.AUTO_COMPACT_THRESHOLD || fileConfig.autoCompactThreshold, 10) || 110000
 };
 
 // 初始化共享上下文

package/package.json

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