evolclaw 2.0.0

package/dist/utils/init.js

@@ -0,0 +1,352 @@
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import readline from 'readline';
+import { createRequire } from 'module';
+import { execFileSync } from 'child_process';
+import { promisify } from 'util';
+import { execFile } from 'child_process';
+import { resolveRoot, resolvePaths, ensureDataDirs, getPackageRoot } from '../paths.js';
+const execFileAsync = promisify(execFile);
+// ==================== Helpers ====================
+function ask(rl, question) {
+    return new Promise(resolve => rl.question(question, resolve));
+}
+async function npmInstallGlobal(pkg) {
+    try {
+        await execFileAsync('npm', ['install', '-g', pkg], { timeout: 120000 });
+    }
+    catch (e) {
+        if (e.stderr?.includes('EACCES') || e.message?.includes('EACCES')) {
+            await execFileAsync('sudo', ['npm', 'install', '-g', pkg], { timeout: 120000 });
+        }
+        else {
+            throw e;
+        }
+    }
+}
+async function sudoExec(cmd, args) {
+    try {
+        await execFileAsync(cmd, args, { timeout: 120000 });
+    }
+    catch (e) {
+        if (e.stderr?.includes('EACCES') || e.message?.includes('EACCES') || e.code === 'EACCES') {
+            await execFileAsync('sudo', [cmd, ...args], { timeout: 120000 });
+        }
+        else {
+            throw e;
+        }
+    }
+}
+// ==================== Environment Check ====================
+async function checkEnvironment(rl) {
+    console.log('🔍 环境检查...\n');
+    // Node.js >= 22
+    const nodeVer = parseInt(process.versions.node.split('.')[0], 10);
+    if (nodeVer >= 22) {
+        console.log(`  ✓ Node.js v${process.versions.node}`);
+    }
+    else {
+        console.log(`  ✗ Node.js v${process.versions.node} — 需要 >= 22（node:sqlite 依赖）`);
+        // 检测 nvm
+        const hasNvm = !!process.env.NVM_DIR && fs.existsSync(process.env.NVM_DIR);
+        if (hasNvm) {
+            const answer = (await ask(rl, '  → 是否通过 nvm 升级到 Node.js 22？[Y/n] ')).trim().toLowerCase();
+            if (answer === 'n' || answer === 'no') {
+                console.log('  已取消');
+                return false;
+            }
+            console.log('  正在升级 Node.js...');
+            try {
+                const nvmDir = process.env.NVM_DIR;
+                const { stdout } = await execFileAsync('bash', ['-c', `source "${nvmDir}/nvm.sh" && nvm install 22 && nvm alias default 22`], { timeout: 120000 });
+                console.log(stdout.trim().split('\n').map(l => `  ${l}`).join('\n'));
+                console.log('  ✓ Node.js 升级完成，请重新运行 evolclaw init');
+                return false;
+            }
+            catch (e) {
+                console.log(`  ✗ 升级失败: ${e.message?.slice(0, 200) || e}`);
+                return false;
+            }
+        }
+        else {
+            // 检测 n
+            let hasN = false;
+            try {
+                execFileSync('which', ['n'], { encoding: 'utf-8' });
+                hasN = true;
+            }
+            catch { }
+            if (hasN) {
+                const answer = (await ask(rl, '  → 是否通过 n 升级到 Node.js 22？[Y/n] ')).trim().toLowerCase();
+                if (answer === 'n' || answer === 'no') {
+                    console.log('  已取消');
+                    return false;
+                }
+                console.log('  正在升级 Node.js...');
+                try {
+                    await sudoExec('n', ['22']);
+                    console.log('  ✓ Node.js 升级完成，请重新运行 evolclaw init');
+                    return false;
+                }
+                catch (e) {
+                    console.log(`  ✗ 升级失败: ${e.message?.slice(0, 200) || e}`);
+                    return false;
+                }
+            }
+            // 无版本管理器，用 npm 安装 n 再升级
+            const answer = (await ask(rl, '  → 是否通过 npm 安装 n 并升级到 Node.js 22？[Y/n] ')).trim().toLowerCase();
+            if (answer === 'n' || answer === 'no') {
+                console.log('  已取消');
+                return false;
+            }
+            console.log('  正在安装 n...');
+            try {
+                await npmInstallGlobal('n');
+                console.log('  正在升级 Node.js...');
+                await sudoExec('n', ['22']);
+                console.log('  ✓ Node.js 升级完成，请重新运行 evolclaw init');
+                return false;
+            }
+            catch (e) {
+                console.log(`  ✗ 升级失败: ${e.message?.slice(0, 200) || e}`);
+                return false;
+            }
+        }
+    }
+    // claude CLI >= 2.1.32
+    const MIN_CLAUDE_VER = [2, 1, 32];
+    let claudeInstalled = false;
+    try {
+        execFileSync('which', ['claude'], { encoding: 'utf-8' });
+        claudeInstalled = true;
+        const verOutput = execFileSync('claude', ['--version'], { encoding: 'utf-8' }).trim();
+        const verMatch = verOutput.match(/^(\d+\.\d+\.\d+)/);
+        if (verMatch) {
+            const parts = verMatch[1].split('.').map(Number);
+            const isOk = parts[0] > MIN_CLAUDE_VER[0]
+                || (parts[0] === MIN_CLAUDE_VER[0] && parts[1] > MIN_CLAUDE_VER[1])
+                || (parts[0] === MIN_CLAUDE_VER[0] && parts[1] === MIN_CLAUDE_VER[1] && parts[2] >= MIN_CLAUDE_VER[2]);
+            if (isOk) {
+                console.log(`  ✓ claude CLI v${verMatch[1]}`);
+            }
+            else {
+                console.log(`  ✗ claude CLI v${verMatch[1]} — 需要 >= ${MIN_CLAUDE_VER.join('.')}`);
+                const answer = (await ask(rl, '  → 是否升级 claude CLI？[Y/n] ')).trim().toLowerCase();
+                if (answer === 'n' || answer === 'no') {
+                    console.log('  已取消');
+                    return false;
+                }
+                console.log('  正在升级 claude CLI...');
+                try {
+                    await npmInstallGlobal('@anthropic-ai/claude-code@latest');
+                    console.log('  ✓ claude CLI 升级完成');
+                }
+                catch (e) {
+                    console.log(`  ✗ 升级失败: ${e.message?.slice(0, 200) || e}`);
+                    return false;
+                }
+            }
+        }
+        else {
+            console.log(`  ✓ claude CLI (${verOutput})`);
+        }
+    }
+    catch {
+        if (!claudeInstalled) {
+            console.log('  ✗ claude CLI 未找到');
+            console.log('  → 请先安装: npm install -g @anthropic-ai/claude-code');
+            return false;
+        }
+    }
+    // @anthropic-ai/claude-agent-sdk >= 0.2.75
+    let sdkAction = 'ok';
+    try {
+        let sdkPkgPath = null;
+        const esmRequire = createRequire(import.meta.url);
+        try {
+            sdkPkgPath = esmRequire.resolve('@anthropic-ai/claude-agent-sdk/package.json');
+        }
+        catch {
+            try {
+                const globalRoot = execFileSync('npm', ['root', '-g'], { encoding: 'utf-8' }).trim();
+                const globalPath = path.join(globalRoot, '@anthropic-ai', 'claude-agent-sdk', 'package.json');
+                if (fs.existsSync(globalPath))
+                    sdkPkgPath = globalPath;
+            }
+            catch { }
+        }
+        if (!sdkPkgPath)
+            throw new Error('not found');
+        const sdkPkg = JSON.parse(fs.readFileSync(sdkPkgPath, 'utf-8'));
+        const sdkVer = sdkPkg.version;
+        const parts = sdkVer.split('.').map(Number);
+        const sdkOk = parts[0] > 0 || parts[1] > 2 || (parts[1] === 2 && parts[2] >= 75);
+        if (sdkOk) {
+            console.log(`  ✓ claude-agent-sdk v${sdkVer}`);
+        }
+        else {
+            console.log(`  ✗ claude-agent-sdk v${sdkVer} — 需要 >= 0.2.75`);
+            sdkAction = 'upgrade';
+        }
+    }
+    catch {
+        console.log('  ✗ claude-agent-sdk 未安装');
+        sdkAction = 'install';
+    }
+    if (sdkAction !== 'ok') {
+        const verb = sdkAction === 'install' ? '安装' : '升级';
+        const answer = (await ask(rl, `  → 是否${verb} claude-agent-sdk？[Y/n] `)).trim().toLowerCase();
+        if (answer === 'n' || answer === 'no') {
+            console.log('  已取消');
+            return false;
+        }
+        console.log(`  正在${verb} claude-agent-sdk...`);
+        try {
+            await npmInstallGlobal('@anthropic-ai/claude-agent-sdk@latest');
+            console.log(`  ✓ claude-agent-sdk ${verb}完成`);
+        }
+        catch (e) {
+            console.log(`  ✗ ${verb}失败: ${e.message?.slice(0, 200) || e}`);
+            return false;
+        }
+    }
+    console.log('');
+    return true;
+}
+// ==================== Shell Profile ====================
+function setupEnvVar(home) {
+    const exportLine = `export EVOLCLAW_HOME="${home}"`;
+    const candidates = [
+        path.join(os.homedir(), '.zshrc'),
+        path.join(os.homedir(), '.bashrc'),
+        path.join(os.homedir(), '.bash_profile'),
+    ];
+    let written = false;
+    for (const profilePath of candidates) {
+        if (!fs.existsSync(profilePath))
+            continue;
+        const content = fs.readFileSync(profilePath, 'utf-8');
+        if (content.includes('EVOLCLAW_HOME')) {
+            console.log(`  ✓ EVOLCLAW_HOME 已在 ${profilePath} 中配置`);
+            written = true;
+            continue;
+        }
+        fs.appendFileSync(profilePath, `\n# EvolClaw\n${exportLine}\n`);
+        console.log(`  ✓ 已写入 ${profilePath}: ${exportLine}`);
+        written = true;
+    }
+    if (!written) {
+        const shell = process.env.SHELL || '/bin/bash';
+        const profilePath = shell.endsWith('zsh')
+            ? path.join(os.homedir(), '.zshrc')
+            : path.join(os.homedir(), '.bashrc');
+        fs.appendFileSync(profilePath, `\n# EvolClaw\n${exportLine}\n`);
+        console.log(`  ✓ 已写入 ${profilePath}: ${exportLine}`);
+    }
+    console.log('  ⚠ 请重新打开终端或执行 source 使其生效');
+}
+// ==================== Main ====================
+export async function cmdInit() {
+    const p = resolvePaths();
+    ensureDataDirs();
+    // 检查服务是否在运行
+    if (fs.existsSync(p.pid)) {
+        const pid = parseInt(fs.readFileSync(p.pid, 'utf-8').trim(), 10);
+        try {
+            process.kill(pid, 0);
+            console.log(`❌ EvolClaw 正在运行 (PID: ${pid})，请先执行 evolclaw stop`);
+            return;
+        }
+        catch { }
+    }
+    const sampleSrc = path.join(getPackageRoot(), 'data', 'evolclaw.sample.json');
+    if (!fs.existsSync(sampleSrc)) {
+        console.log(`❌ 找不到示例配置: ${sampleSrc}`);
+        return;
+    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        if (fs.existsSync(p.config)) {
+            const answer = (await ask(rl, `配置文件已存在: ${p.config}\n  是否重新初始化？[y/N] `)).trim().toLowerCase();
+            if (answer !== 'y' && answer !== 'yes') {
+                console.log('  已取消');
+                return;
+            }
+        }
+        if (!await checkEnvironment(rl)) {
+            return;
+        }
+        console.log('📝 交互式配置\n');
+        // feishu.appId
+        let appId = '';
+        while (!appId) {
+            appId = (await ask(rl, '  飞书 App ID: ')).trim();
+            if (!appId)
+                console.log('  ⚠ 不能为空');
+        }
+        // feishu.appSecret
+        let appSecret = '';
+        while (!appSecret) {
+            appSecret = (await ask(rl, '  飞书 App Secret: ')).trim();
+            if (!appSecret)
+                console.log('  ⚠ 不能为空');
+        }
+        // 验证飞书凭证
+        console.log('  正在验证飞书凭证...');
+        try {
+            const lark = await import('@larksuiteoapi/node-sdk');
+            const client = new lark.Client({ appId, appSecret });
+            const res = await client.auth.tenantAccessToken.internal({
+                data: { app_id: appId, app_secret: appSecret },
+            });
+            if (res.code === 0) {
+                console.log('  ✓ 飞书凭证验证通过');
+            }
+            else {
+                console.log(`  ✗ 飞书凭证验证失败: ${res.msg}`);
+                const answer = (await ask(rl, '  → 是否继续？[y/N] ')).trim().toLowerCase();
+                if (answer !== 'y' && answer !== 'yes') {
+                    console.log('  已取消');
+                    return;
+                }
+            }
+        }
+        catch (e) {
+            console.log(`  ⚠ 飞书凭证验证跳过: ${e.message?.slice(0, 100) || e}`);
+        }
+        // projects.defaultPath
+        const defaultSuggestion = path.join(os.homedir(), 'evolclaw-project');
+        let defaultPath = (await ask(rl, `  默认项目路径 [${defaultSuggestion}]: `)).trim();
+        if (!defaultPath) {
+            defaultPath = defaultSuggestion;
+        }
+        if (defaultPath.startsWith('~/')) {
+            defaultPath = path.join(os.homedir(), defaultPath.slice(2));
+        }
+        else if (defaultPath === '~') {
+            defaultPath = os.homedir();
+        }
+        if (!fs.existsSync(defaultPath)) {
+            fs.mkdirSync(defaultPath, { recursive: true });
+            console.log(`  ✓ 已创建目录: ${defaultPath}`);
+        }
+        // anthropic.model
+        const modelInput = (await ask(rl, '  模型 [sonnet(默认)/opus/haiku]: ')).trim().toLowerCase();
+        const model = ['opus', 'haiku'].includes(modelInput) ? modelInput : 'sonnet';
+        // Generate config
+        const config = JSON.parse(fs.readFileSync(sampleSrc, 'utf-8'));
+        config.feishu.appId = appId;
+        config.feishu.appSecret = appSecret;
+        config.projects.defaultPath = defaultPath;
+        config.projects.list = { [path.basename(defaultPath)]: defaultPath };
+        config.anthropic.model = model;
+        fs.writeFileSync(p.config, JSON.stringify(config, null, 2) + '\n');
+        console.log(`\n✓ 已创建配置文件: ${p.config}`);
+        // Setup EVOLCLAW_HOME in shell profile
+        setupEnvVar(resolveRoot());
+    }
+    finally {
+        rl.close();
+    }
+}

package/dist/utils/logger.js

@@ -0,0 +1,47 @@
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths } from '../paths.js';
+const LOG_DIR = resolvePaths().logs;
+const LOG_LEVEL = process.env.LOG_LEVEL || 'INFO';
+const LEVELS = { DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3 };
+const config = {
+    messageLog: process.env.MESSAGE_LOG === 'true',
+    eventLog: process.env.EVENT_LOG === 'true'
+};
+if (!fs.existsSync(LOG_DIR)) {
+    fs.mkdirSync(LOG_DIR, { recursive: true });
+}
+const streams = {
+    main: fs.createWriteStream(path.join(LOG_DIR, 'evolclaw.log'), { flags: 'a' }),
+    message: config.messageLog ? fs.createWriteStream(path.join(LOG_DIR, 'messages.log'), { flags: 'a' }) : null,
+    event: config.eventLog ? fs.createWriteStream(path.join(LOG_DIR, 'events.log'), { flags: 'a' }) : null
+};
+function shouldLog(level) {
+    return LEVELS[level] >= LEVELS[LOG_LEVEL];
+}
+function write(stream, data) {
+    if (!stream)
+        return;
+    const line = typeof data === 'string' ? data : JSON.stringify(data);
+    stream.write(`${line}\n`);
+}
+function log(level, ...args) {
+    if (!shouldLog(level))
+        return;
+    const timestamp = new Date().toISOString();
+    const msg = `[${timestamp}] [${level}] ${args.join(' ')}`;
+    // 只写文件，不输出到 console（避免重定向时重复）
+    write(streams.main, msg);
+}
+export const logger = {
+    debug: (...args) => log('DEBUG', ...args),
+    info: (...args) => log('INFO', ...args),
+    warn: (...args) => log('WARN', ...args),
+    error: (...args) => log('ERROR', ...args),
+    message: (data) => {
+        write(streams.message, { ts: new Date().toISOString(), ...data });
+    },
+    event: (data) => {
+        write(streams.event, { ts: new Date().toISOString(), ...data });
+    }
+};

package/dist/utils/markdown-to-feishu.js

@@ -0,0 +1,38 @@
+/**
+ * Markdown 到飞书富文本格式转换工具
+ * 使用飞书 post 格式的 md tag 原生渲染 Markdown
+ */
+/**
+ * 将 Markdown 文本转换为飞书 post 消息格式
+ * 利用 md tag 让飞书原生渲染，支持代码高亮、嵌套列表、引用等全部语法
+ */
+export function markdownToFeishuPost(markdown, defaultTitle) {
+    const match = markdown.match(/^# (.+)$/m);
+    const title = match?.[1] ?? defaultTitle ?? '';
+    const body = match ? markdown.replace(/^# .+\n?/, '') : markdown;
+    return {
+        zh_cn: {
+            title,
+            content: [[{ tag: 'md', text: body.trim() }]]
+        }
+    };
+}
+/**
+ * 检测文本是否包含 Markdown 语法
+ */
+export function hasMarkdownSyntax(text) {
+    const markdownPatterns = [
+        /^#{1,6}\s/m, // 标题
+        /\*\*.*?\*\*/, // 粗体
+        /\*.*?\*/, // 斜体
+        /__.*?__/, // 粗体
+        /_.*?_/, // 斜体
+        /~~.*?~~/, // 删除线
+        /`.*?`/, // 行内代码
+        /```[\s\S]*?```/, // 代码块
+        /\[.*?\]\(.*?\)/, // 链接
+        /^[\s]*[-*+]\s/m, // 无序列表
+        /^[\s]*\d+\.\s/m // 有序列表
+    ];
+    return markdownPatterns.some(pattern => pattern.test(text));
+}

package/dist/utils/permission.js

@@ -0,0 +1,36 @@
+// 危险命令黑名单（正则表达式）
+const DANGEROUS_PATTERNS = [
+    /\brm\s+-\w*r\w*f/, // rm -rf
+    /\bsudo\b/, // sudo
+    /\bmkfs\b/, // mkfs (格式化文件系统)
+    /\bdd\s+if=/, // dd (磁盘操作)
+    /\bchmod\s+777/, // chmod 777 (危险权限)
+    />\s*\/dev\//, // 重定向到设备文件
+    /\bshutdown\b/, // 关机
+    /\breboot\b/, // 重启
+];
+/**
+ * 权限检查回调函数
+ * 符合 Claude Agent SDK 的 can_use_tool 接口
+ */
+export async function canUseTool(toolName, input) {
+    // 只检查 Bash 工具，其余工具全部放行
+    if (toolName === 'Bash') {
+        const cmd = input.command || '';
+        // 空命令直接放行
+        if (!cmd || cmd.trim() === '') {
+            return { behavior: 'allow', updatedInput: input };
+        }
+        // 检查黑名单
+        for (const pattern of DANGEROUS_PATTERNS) {
+            if (pattern.test(cmd)) {
+                return {
+                    behavior: 'deny',
+                    message: `⛔ 危险命令被拦截: ${cmd.substring(0, 80)}`
+                };
+            }
+        }
+    }
+    // 默认允许
+    return { behavior: 'allow', updatedInput: input };
+}

package/dist/utils/session-file-health.js

@@ -0,0 +1,67 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { logger } from './logger.js';
+/**
+ * 检查会话文件是否存在
+ */
+async function fileExists(filePath) {
+    try {
+        await fs.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * 检查会话文件健康度
+ */
+export async function checkSessionFileHealth(projectPath, claudeSessionId) {
+    const issues = [];
+    const sessionFile = path.join(projectPath, '.claude', `${claudeSessionId}.jsonl`);
+    // 检查文件是否存在
+    if (!(await fileExists(sessionFile))) {
+        // 新会话没有文件是正常的
+        return { healthy: true, issues: [] };
+    }
+    try {
+        // 检查文件大小
+        const stats = await fs.stat(sessionFile);
+        const sizeMB = stats.size / (1024 * 1024);
+        if (stats.size > 50 * 1024 * 1024) {
+            issues.push(`会话文件过大: ${sizeMB.toFixed(1)}MB`);
+        }
+        // 检查 JSON 格式
+        const content = await fs.readFile(sessionFile, 'utf-8');
+        const lines = content.split('\n').filter(l => l.trim());
+        for (let i = 0; i < lines.length; i++) {
+            try {
+                JSON.parse(lines[i]);
+            }
+            catch (e) {
+                issues.push(`会话文件格式损坏（第 ${i + 1} 行）`);
+                return { healthy: false, issues, corrupt: true, fileSize: stats.size };
+            }
+        }
+        return {
+            healthy: issues.length === 0,
+            issues,
+            fileSize: stats.size
+        };
+    }
+    catch (error) {
+        logger.error('[SessionFileHealth] Check failed:', error);
+        issues.push(`文件读取失败: ${error.message}`);
+        return { healthy: false, issues, corrupt: true };
+    }
+}
+/**
+ * 备份会话目录
+ */
+export async function backupClaudeDir(projectPath) {
+    const claudeDir = path.join(projectPath, '.claude');
+    const backupDir = path.join(claudeDir, `backup-${Date.now()}`);
+    await fs.cp(claudeDir, backupDir, { recursive: true });
+    logger.info(`[SessionFileHealth] Backup created: ${backupDir}`);
+    return backupDir;
+}

package/dist/utils/stream-flusher.js

@@ -0,0 +1,151 @@
+/**
+ * 流式输出缓冲器
+ * 按时间窗口批量推送文本和活动事件
+ *
+ * 延迟策略：
+ * - 第1次：立即发送（0ms）
+ * - 第2-4次：半延迟（interval / 2）
+ * - 第5次起：动态自适应延迟
+ *   - 计算最近10条消息的平均间隔
+ *   - 动态延迟 = 平均间隔 * 3
+ *   - 下限：interval（额定值）
+ *   - 上限：interval * 2.5
+ */
+export class StreamFlusher {
+    send;
+    interval;
+    buffer = '';
+    activities = [];
+    timer;
+    lastFlush = Date.now();
+    allText = '';
+    sentContent = false;
+    fileMarkerPattern;
+    flushCount = 0;
+    messageTimestamps = [];
+    constructor(send, interval = 4000, fileMarkerPattern) {
+        this.send = send;
+        this.interval = interval;
+        this.fileMarkerPattern = fileMarkerPattern;
+    }
+    addText(text) {
+        this.buffer += text;
+        this.allText += text;
+        this.messageTimestamps.push(Date.now());
+        this.scheduleFlush();
+    }
+    addTextBlock(text) {
+        // 用于 assistant 事件的完整文本块，需要换行分隔
+        if (this.buffer && !this.buffer.endsWith('\n')) {
+            this.buffer += '\n\n';
+            this.allText += '\n\n';
+        }
+        this.buffer += text;
+        this.allText += text;
+        this.messageTimestamps.push(Date.now());
+        this.scheduleFlush();
+    }
+    addActivity(desc) {
+        this.activities.push(desc);
+        this.messageTimestamps.push(Date.now());
+        this.scheduleFlush();
+    }
+    /** 当前 buffer 中是否有待发送内容 */
+    hasContent() {
+        return this.buffer.length > 0 || this.activities.length > 0;
+    }
+    /** 是否曾经发送过任何内容 */
+    hasSentContent() {
+        return this.sentContent;
+    }
+    /** 获取完整累积文本（用于文件标记提取） */
+    getFinalText() {
+        return this.allText;
+    }
+    /** 获取当前未发送的剩余文本 */
+    getRemainingText() {
+        return this.buffer;
+    }
+    /** 从当前 buffer 中移除匹配的模式 */
+    stripFromBuffer(pattern) {
+        this.buffer = this.buffer.replace(pattern, '').trim();
+    }
+    scheduleFlush() {
+        if (this.timer)
+            return;
+        // 计算目标延迟
+        let targetDelay;
+        if (this.flushCount === 0) {
+            // 第1次：立即发送
+            targetDelay = 0;
+        }
+        else if (this.flushCount <= 3) {
+            // 第2-4次：半延迟
+            targetDelay = Math.ceil(this.interval / 2);
+        }
+        else if (this.messageTimestamps.length >= 5) {
+            // 第5次起：动态自适应
+            targetDelay = this.calculateDynamicDelay();
+        }
+        else {
+            // 样本不足，使用额定延迟
+            targetDelay = this.interval;
+        }
+        const elapsed = Date.now() - this.lastFlush;
+        const delay = Math.max(0, targetDelay - elapsed);
+        this.timer = setTimeout(() => this.flush(), delay);
+    }
+    /**
+     * 计算动态延迟
+     * 基于最近10条消息的平均间隔
+     */
+    calculateDynamicDelay() {
+        // 取最近10条（或实际条数）
+        const recent = this.messageTimestamps.slice(-10);
+        // 计算平均间隔
+        const intervals = [];
+        for (let i = 1; i < recent.length; i++) {
+            intervals.push(recent[i] - recent[i - 1]);
+        }
+        if (intervals.length === 0) {
+            return this.interval;
+        }
+        const avgInterval = intervals.reduce((a, b) => a + b) / intervals.length;
+        // 动态延迟 = 平均间隔 * 3
+        let dynamicDelay = avgInterval * 3;
+        // 边界限制
+        const minDelay = this.interval; // 下限：额定值
+        const maxDelay = this.interval * 2.5; // 上限：额定值 * 2.5
+        return Math.max(minDelay, Math.min(maxDelay, dynamicDelay));
+    }
+    async flush(isFinal) {
+        if (this.timer) {
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        let output = '';
+        if (this.activities.length > 0) {
+            output += this.activities.join('\n') + '\n\n';
+            this.activities = [];
+        }
+        if (this.buffer) {
+            output += this.buffer;
+            this.buffer = '';
+        }
+        // 移除文件标记（如果配置了）
+        if (output && this.fileMarkerPattern) {
+            const before = output;
+            output = output.replace(this.fileMarkerPattern, '').trim();
+            if (before !== output) {
+                console.log('[StreamFlusher] Removed file markers, before length:', before.length, 'after:', output.length);
+            }
+        }
+        console.log('[StreamFlusher] flush called, output length:', output.length, 'isEmpty:', !output, 'preview:', output.substring(0, 100));
+        if (output) {
+            await this.send(output, isFinal);
+            this.sentContent = true;
+            this.lastFlush = Date.now();
+            this.flushCount++;
+        }
+    }
+}