@bolloon/bolloon-agent 0.2.1 → 0.2.3

package/dist/workflows/collaboration.js

@@ -0,0 +1,374 @@
+/**
+ * Multi-Agent Collaboration Workflow
+ *
+ * 工作流设计：
+ * 1. 命令解析 - 理解用户意图
+ * 2. DID查询 - 从IPNS/IPFS查找已注册智能体
+ * 3. 协作判断 - 分析是否需要多智能体协作
+ * 4. 任务分发 - 发送文档给其他智能体
+ * 5. 结果汇总 - 收集并整合协作结果
+ */
+import { AgentProtocol } from '../agents/protocol.js';
+import { p2pNetwork } from '../network/p2p.js';
+import { documentReader } from '../documents/reader.js';
+import { getMinimax } from '../constraints/index.js';
+import { IpfsClient } from '@diap/sdk';
+/**
+ * 命令解析器 - 将用户输入解析为结构化意图
+ */
+export class CommandParser {
+    collaborationKeywords = ['协作', '合作', '其他', '帮忙', '请教', '团队', '分享', '交给'];
+    improvementKeywords = ['改进', '优化', '修改', '完善', '润色', '修正'];
+    queryKeywords = ['查看', '列表', '查询', '有哪些', '谁在线'];
+    parse(input, context) {
+        const lowerInput = input.toLowerCase();
+        // 检测是否需要协作
+        const needCollaboration = this.collaborationKeywords.some(k => lowerInput.includes(k));
+        // 解析动作
+        let action = 'query';
+        if (lowerInput.includes('改进') || lowerInput.includes('优化') || lowerInput.includes('修改')) {
+            action = 'improve';
+        }
+        else if (lowerInput.includes('总结') || lowerInput.includes('摘要')) {
+            action = 'summarize';
+        }
+        else if (lowerInput.includes('读取') || lowerInput.includes('阅读')) {
+            action = 'read';
+        }
+        else if (lowerInput.includes('汇报') || lowerInput.includes('报告')) {
+            action = 'report';
+        }
+        else if (this.queryKeywords.some(k => lowerInput.includes(k))) {
+            action = 'query';
+        }
+        // 提取目标文件/主题
+        const targetMatch = input.match(/[\w\.\/]+\.(md|txt|pdf|docx)/i);
+        const target = targetMatch ? targetMatch[0] : undefined;
+        // 提取需求描述
+        const requirements = this.extractRequirements(input);
+        // 识别建议的智能体（如果有）
+        const suggestedAgents = this.extractAgentNames(input);
+        return {
+            action,
+            target,
+            requirements,
+            context: context || input,
+            needCollaboration,
+            suggestedAgents
+        };
+    }
+    extractRequirements(input) {
+        // 查找引号内的内容或特定模式
+        const quotes = input.match(/["'""]([^""']+)[""'"]/);
+        if (quotes)
+            return quotes[1];
+        const afterKeywords = input.match(/(?:改进|优化|修改|要求|需要)[:：]\s*(.+)/i);
+        if (afterKeywords)
+            return afterKeywords[1];
+        return undefined;
+    }
+    extractAgentNames(input) {
+        const names = input.match(/[@@]\w+/g);
+        return names ? names.map(n => n.substring(1)) : undefined;
+    }
+}
+/**
+ * DID注册表 - 管理已知智能体的DID信息
+ */
+export class DIDRegistry {
+    agents = new Map();
+    ipfsClient;
+    constructor(ipfsApiUrl = 'http://127.0.0.1:5001') {
+        this.ipfsClient = new IpfsClient(ipfsApiUrl, null);
+    }
+    async registerAgent(agent) {
+        this.agents.set(agent.did, {
+            ...agent,
+            lastSeen: Date.now()
+        });
+    }
+    async unregisterAgent(did) {
+        this.agents.delete(did);
+    }
+    getAgent(did) {
+        return this.agents.get(did);
+    }
+    getAllAgents() {
+        return Array.from(this.agents.values());
+    }
+    getOnlineAgents() {
+        const now = Date.now();
+        const timeout = 5 * 60 * 1000; // 5分钟超时
+        return this.getAllAgents().filter(a => a.lastSeen && (now - a.lastSeen) < timeout);
+    }
+    async resolveDIDFromIPNS(ipnsName) {
+        try {
+            const cid = await this.ipfsClient.resolveIpns(ipnsName);
+            const content = await this.ipfsClient.get(cid);
+            const doc = JSON.parse(content);
+            return {
+                did: doc.id,
+                name: doc.name || doc.id,
+                ipnsName
+            };
+        }
+        catch (error) {
+            console.error(`Failed to resolve DID from IPNS ${ipnsName}:`, error);
+            return null;
+        }
+    }
+    async discoverAgents() {
+        const discovered = [];
+        const peers = p2pNetwork.getPeers();
+        for (const peerId of peers) {
+            // 尝试从已知IPNS名称列表中解析
+            // 实际实现中应该通过某种服务发现机制
+            const agent = this.getAgentByPeerId(peerId);
+            if (agent) {
+                discovered.push(agent);
+            }
+        }
+        return discovered;
+    }
+    getAgentByPeerId(peerId) {
+        for (const agent of this.agents.values()) {
+            if (agent.peerId === peerId) {
+                return agent;
+            }
+        }
+        return undefined;
+    }
+}
+/**
+ * 协作决策器 - 判断是否需要多智能体协作
+ */
+export class CollaborationDecider {
+    threshold = 0.7;
+    async shouldCollaborate(intent, qualityScore) {
+        // 明确要求协作
+        if (intent.needCollaboration)
+            return true;
+        // 质量问题，建议协作改进
+        if (qualityScore && qualityScore < this.threshold)
+            return true;
+        // 复杂任务建议协作
+        if (intent.action === 'improve' && intent.requirements) {
+            if (intent.requirements.length > 200)
+                return true; // 复杂需求
+        }
+        return false;
+    }
+    selectAgentsForTask(intent, availableAgents) {
+        if (!availableAgents.length)
+            return [];
+        // 如果用户指定了智能体
+        if (intent.suggestedAgents?.length) {
+            return availableAgents.filter(a => intent.suggestedAgents.some(name => a.name.includes(name) || a.did.includes(name)));
+        }
+        // 根据任务类型选择
+        switch (intent.action) {
+            case 'improve':
+                // 改进任务可以选多个智能体并行处理
+                return availableAgents.slice(0, 3);
+            case 'summarize':
+                // 摘要任务选一个即可
+                return [availableAgents[0]];
+            default:
+                return availableAgents.slice(0, 2);
+        }
+    }
+}
+/**
+ * 任务分发器 - 管理多智能体任务分发和结果收集
+ */
+export class TaskDispatcher {
+    protocol;
+    pendingTasks = new Map();
+    constructor(protocol) {
+        this.protocol = protocol;
+    }
+    async dispatchSummarize(intent, target, agents) {
+        const taskId = `summarize-${Date.now()}`;
+        this.pendingTasks.set(taskId, { intent, agents });
+        // 广播任务给选定的智能体
+        for (const agent of agents) {
+            const task = {
+                taskId,
+                action: 'summarize',
+                target,
+                context: intent.context
+            };
+            await this.protocol.sendTask(task, agent.peerId || agent.did);
+        }
+        return taskId;
+    }
+    async dispatchImprove(intent, target, agents) {
+        const taskId = `improve-${Date.now()}`;
+        this.pendingTasks.set(taskId, { intent, agents });
+        // 向每个智能体发送改进请求
+        for (const agent of agents) {
+            await this.protocol.requestImprove(target, intent.requirements || '', agent.peerId);
+        }
+        return taskId;
+    }
+    cancelTask(taskId) {
+        this.pendingTasks.delete(taskId);
+    }
+    getPendingTasks() {
+        return Array.from(this.pendingTasks.keys());
+    }
+}
+/**
+ * 多智能体协作工作流 - 主协调器
+ */
+export class MultiAgentWorkflow {
+    parser;
+    registry;
+    decider;
+    dispatcher;
+    protocol;
+    constructor() {
+        this.parser = new CommandParser();
+        this.registry = new DIDRegistry();
+        this.decider = new CollaborationDecider();
+        this.protocol = new AgentProtocol('local', 'coordinator');
+        this.dispatcher = new TaskDispatcher(this.protocol);
+        this.setupResultHandlers();
+    }
+    setupResultHandlers() {
+        // 处理返回结果
+        p2pNetwork.onMessage('result', async (data, from) => {
+            const msg = JSON.parse(new TextDecoder().decode(data));
+            const result = JSON.parse(msg.payload);
+            console.log(`\n📥 收到来自 ${from} 的结果:`);
+            console.log(`   质量: ${(result.qualityScore * 10).toFixed(1)}/10`);
+            console.log(`   摘要: ${result.result?.substring(0, 100)}...`);
+        });
+        // 处理改进结果
+        p2pNetwork.onMessage('improved', async (data, from) => {
+            const msg = JSON.parse(new TextDecoder().decode(data));
+            const result = JSON.parse(msg.payload);
+            console.log(`\n✨ 收到来自 ${from} 的改进结果:`);
+            console.log(`   质量: ${(result.qualityScore * 10).toFixed(1)}/10`);
+            console.log(`   自动发送: ${result.shouldAutoSend ? '是' : '否'}`);
+        });
+    }
+    /**
+     * 处理用户输入的完整流程
+     */
+    async process(input, context) {
+        // 1. 命令解析
+        const intent = this.parser.parse(input, context);
+        console.log(`\n🔍 解析命令:`, intent);
+        // 2. 发现可用的智能体
+        const agents = await this.registry.discoverAgents();
+        console.log(`\n👥 发现 ${agents.length} 个在线智能体`);
+        // 3. 协作决策
+        const shouldCollaborate = await this.decider.shouldCollaborate(intent);
+        console.log(`\n🤔 协作决策: ${shouldCollaborate ? '需要协作' : '独立完成'}`);
+        if (!shouldCollaborate) {
+            // 独立执行
+            return this.executeIndependently(intent);
+        }
+        // 4. 选择执行智能体
+        const selectedAgents = this.decider.selectAgentsForTask(intent, agents);
+        console.log(`\n🎯 选中 ${selectedAgents.length} 个智能体执行`);
+        if (selectedAgents.length === 0) {
+            // 没有可用智能体，降级为独立执行
+            console.log(`\n⚠️ 没有可用智能体，降级为独立执行`);
+            return this.executeIndependently(intent);
+        }
+        // 5. 分发任务
+        return this.dispatchToAgents(intent, selectedAgents);
+    }
+    /**
+     * 独立执行（无需协作）
+     */
+    async executeIndependently(intent) {
+        try {
+            let result;
+            let qualityScore = 0.5;
+            if (intent.action === 'read' || intent.action === 'summarize') {
+                if (!intent.target) {
+                    return { success: false, collaborated: false, agents: [], error: '缺少目标文件' };
+                }
+                const content = await documentReader.read(intent.target);
+                const llm = getMinimax();
+                const summarizeResult = await llm.summarize(content.text, intent.context);
+                result = summarizeResult.summary;
+                qualityScore = summarizeResult.qualityScore;
+            }
+            else if (intent.action === 'improve' && intent.target) {
+                const content = await documentReader.read(intent.target);
+                const llm = getMinimax();
+                result = await llm.improveContent(content.text, intent.requirements || '', intent.context);
+                qualityScore = llm.estimateQuality(content.text, result);
+            }
+            else {
+                return { success: false, collaborated: false, agents: [], error: '未知动作' };
+            }
+            return {
+                success: true,
+                collaborated: false,
+                agents: [],
+                result,
+                qualityScore
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                collaborated: false,
+                agents: [],
+                error: String(error)
+            };
+        }
+    }
+    /**
+     * 分发给多个智能体协作执行
+     */
+    async dispatchToAgents(intent, agents) {
+        try {
+            if (!intent.target) {
+                return { success: false, collaborated: true, agents, error: '缺少目标文件' };
+            }
+            let taskId;
+            if (intent.action === 'summarize' || intent.action === 'read') {
+                taskId = await this.dispatcher.dispatchSummarize(intent, intent.target, agents);
+            }
+            else if (intent.action === 'improve') {
+                taskId = await this.dispatcher.dispatchImprove(intent, intent.target, agents);
+            }
+            else {
+                return { success: false, collaborated: true, agents, error: '不支持的协作动作' };
+            }
+            return {
+                success: true,
+                collaborated: true,
+                agents,
+                taskId,
+                result: `任务已分发，等待结果...`
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                collaborated: true,
+                agents,
+                error: String(error)
+            };
+        }
+    }
+    /**
+     * 查询当前在线的智能体
+     */
+    async listAgents() {
+        return this.registry.discoverAgents();
+    }
+    /**
+     * 注册一个新智能体
+     */
+    async registerAgent(agent) {
+        await this.registry.registerAgent(agent);
+    }
+}

package/dist/workflows/index.js

@@ -0,0 +1,54 @@
+/**
+ * Multi-Agent Collaboration Workflows
+ *
+ * 工作流设计文档：
+ *
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │                      用户输入                              │
+ * └─────────────────────────────────────────────────────────────┘
+ *                            │
+ *                            ▼
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │                   命令解析器 (CommandParser)                │
+ * │  - 识别动作: read/summarize/improve/query/collaborate      │
+ * │  - 提取目标文件、需求描述                                  │
+ * │  - 检测协作关键词                                         │
+ * └─────────────────────────────────────────────────────────────┘
+ *                            │
+ *                            ▼
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │                  DID注册表 (DIDRegistry)                    │
+ * │  - 管理已知智能体的DID信息                                │
+ * │  - 从IPNS解析其他智能体DID文档                            │
+ * │  - 追踪在线状态                                           │
+ * └─────────────────────────────────────────────────────────────┘
+ *                            │
+ *                            ▼
+ * ┌─────────────────────────────────────────────────────────────┐
+ * │                 协作决策器 (CollaborationDecider)           │
+ * │  - 基于任务复杂度、关键词、质量评分决策                     │
+ * │  - 选择合适的执行智能体                                   │
+ * └─────────────────────────────────────────────────────────────┘
+ *                            │
+ *              ┌─────────────┴─────────────┐
+ *              │                           │
+ *              ▼                           ▼
+ *    ┌─────────────────┐       ┌─────────────────┐
+ *    │    独立执行      │       │   多智能体协作   │
+ *    │  - 直接处理      │       │                 │
+ *    │  - 返回结果      │       │  - 分发任务     │
+ *    └─────────────────┘       │  - 收集结果     │
+ *                              │  - 汇总汇报     │
+ *                              └─────────────────┘
+ *                                       │
+ *                                       ▼
+ *                              ┌─────────────────┐
+ *                              │   任务分发器     │
+ *                              │ (TaskDispatcher) │
+ *                              │                 │
+ *                              │ - Protocol发送  │
+ *                              │ - 任务追踪      │
+ *                              │ - 结果收集      │
+ *                              └─────────────────┘
+ */
+export { CommandParser, DIDRegistry, CollaborationDecider, TaskDispatcher, MultiAgentWorkflow } from './collaboration.js';

package/package.json

@@ -1,10 +1,19 @@
 {
   "name": "@bolloon/bolloon-agent",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "type": "module",
   "description": "P2P AI Document Agent - 全局安装后执行 `bolloon` 启动产品",
-  "main": "dist/cli.js",
-  "author": "Bolloon Team",
+  "main": "dist/cli-entry.js",
+  "author": "Bolloon Leo",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/logos-42/bolloon.git"
+  },
+  "license": "MIT",
+  "files": [
+    "dist",
+    "bin"
+  ],
   "bin": {
     "bolloon": "./bin/bolloon-cli.cjs"
   },
@@ -23,6 +32,8 @@
     "electron:dev": "concurrently \"npm run dev:web\" \"npm run electron:start\"",
     "electron:build": "npm run build:electron && electron-builder",
     "electron:pack": "electron-builder --dir",
+    "app:bundle": "node scripts/build-app-bundle.cjs",
+    "app:bundle:open": "node scripts/build-app-bundle.cjs && open \"release/mac-arm64/Bolloon Agent.app\"",
     "test": "vitest run",
     "test:watch": "vitest",
     "test:pi-sdk": "tsx src/test/pi-sdk.test.ts",
@@ -34,6 +45,8 @@
   "dependencies": {
     "@bolloon/bolloon-agent": "^0.1.36",
     "@bolloon/constraint-runtime": "0.1.0",
+    "@capacitor/core": "^8.4.1",
+    "@capacitor/ios": "^8.4.1",
     "@chainsafe/libp2p-noise": "^17.0.0",
     "@chainsafe/libp2p-yamux": "^8.0.1",
     "@diap/sdk": "^0.1.10",
@@ -60,6 +73,7 @@
     "viem": "^2.52.0"
   },
   "devDependencies": {
+    "@capacitor/cli": "^8.4.1",
     "@playwright/test": "^1.60.0",
     "@types/express": "^5.0.6",
     "@types/node": "^25.9.1",
@@ -68,7 +82,7 @@
     "@types/react-dom": "^18.3.0",
     "concurrently": "^9.2.1",
     "electron": "^42.3.0",
-    "electron-builder": "^26.8.1",
+    "electron-builder": "^26.15.5",
     "lefthook": "^2.1.9",
     "playwright": "^1.60.0",
     "tsx": "^4.0.0",

package/.comm/README.md

@@ -1,21 +0,0 @@
-# .comm/ — 跨机聊天收件箱
-
-Bolloon chat transport: commits-as-messages.
-每条消息 = 一个 markdown 文件 + 一次 git commit + push.
-
-## 目录约定
-
-- `<role>/` — 每个 role 一个子目录, 里面是该角色发的所有消息
-- `_state/` — 本地运行态 (cursor, seen, lock), 不 commit
-- `_inbox/` — 看门狗把对方消息反写到本地, 不 commit
-
-## 子命令
-
-```
-bolloon --chat-init
-bolloon --chat-send "..."
-bolloon --chat-pull
-bolloon --chat-list
-bolloon --chat-watch
-bolloon --chat-status
-```

package/.comm/default/2026-06-17T08-23-00-017Z-8a735de8.md

@@ -1,7 +0,0 @@
----
-v: 1
-from: default
-fromPk: d2e7473e4a2f8e6057d6c000f2146109585ed3bdb387233c5f9fecdd0c57d17d
-ts: 2026-06-17T08:23:00.017Z
----
-今天把 chat transport 装上了, 测试一下两台电脑能不能通过 github 同步消息

package/CLAUDE.md

@@ -1,3 +0,0 @@
-
-<!-- bolloon-classify -->
-**变更分类**: implementation | 修复用户登录页面样式 | 2026-06-18

package/scripts/auto-evolve-oneshot.sh

@@ -1,155 +0,0 @@
-#!/bin/bash
-# auto-evolve-oneshot.sh — 阶段 D 单次修复 (shell 版)
-#
-# 流程 (全本地, 用 MINIMAX_API_KEY 调 LLM):
-#   1. 跑 vitest, 抓 fail
-#   2. 让 LLM 修 
-#   3. 解析 LLM 输出的 diff, 写到 staging
-#   4. 跑 reviewer (护栏 4)
-#   5. PASS → git apply + commit (护栏 1 拦)
-
-set -uo pipefail  # 不加 -e: vitest 失败要继续
-
-REPO="$(cd "$(dirname "$0")/.." && pwd)"
-cd "$REPO"
-
-echo "[oneshot] REPO=$REPO"
-
-# 1. 跑 vitest
-npx vitest run --reporter=json --no-color 2>/dev/null > /tmp/vt-out.json
-TOTAL_FAIL=$(python3 -c "
-import json
-d = json.load(open('/tmp/vt-out.json'))
-print(sum(1 for f in d.get('testResults',[]) for a in f.get('assertionResults',[]) if a.get('status')=='failed'))
-")
-echo "[oneshot] vitest failed=$TOTAL_FAIL"
-
-if [ "$TOTAL_FAIL" = "0" ]; then
-  echo "[oneshot] ✅ 全部通过, 不需要修"
-  exit 0
-fi
-
-# 2. 抽 fail 信息
-FAIL_SUMMARY=$(python3 -c "
-import json
-d = json.load(open('/tmp/vt-out.json'))
-for f in d.get('testResults', []):
-    for a in f.get('assertionResults', []):
-        if a.get('status') == 'failed':
-            print('FILE:', f.get('name'))
-            print('TEST:', a.get('fullName') or a.get('title'))
-            print('ERROR:')
-            for m in a.get('failureMessages', [])[:2]:
-                print(m[:600])
-            print('---')
-" | head -60)
-echo "[oneshot] 2. 调 LLM 修..."
-
-# 3. 用 LLM 生成修复
-# prompt: 要 LLM 输出 ```diff ... ``` 块
-# 3. 写 prompt 到文件 (避免 shell 反引号冲突)
-PROMPT_FILE="/tmp/oneshot-prompt.txt"
-cat > "$PROMPT_FILE" <<PROMPT_EOF
-你是一个谨慎的代码修复助手. 你的工作是修复失败的测试.
-
-约束: 改动最小, 不改测试, 不引入 any/unknown/@ts-ignore.
-
-输出格式: 严格只输出一个 \`\`\`diff ... \`\`\` 块, 第一个字符 \`\`\`diff, 最后一个字符 \`\`\`. 中间是 unified diff (--- a/path +++ b/path 风格). 不要在 diff 块外输出任何文字.
-
-FAIL 信息:
-$(cat /tmp/vt-out.json | python3 -c "
-import json
-d = json.load(open('/tmp/vt-out.json'))
-for f in d.get('testResults', []):
-    for a in f.get('assertionResults', []):
-        if a.get('status') == 'failed':
-            print('FILE:', f.get('name'))
-            print('TEST:', a.get('fullName') or a.get('title'))
-            print('ERROR:')
-            for m in a.get('failureMessages', [])[:2]:
-                print(m[:600])
-            print('---')
-" | head -60)
-
-请**只**输出 diff 块:
-PROMPT_EOF
-
-LLM_OUTPUT=$(npx tsx -r dotenv/config -e "
-import { initMinimax } from './src/llm/pi-ai.js';
-import * as fs from 'fs';
-const prompt = fs.readFileSync('$PROMPT_FILE', 'utf-8');
-const client = initMinimax();
-const text = await client.generateText({ messages: [{ role: 'user', content: prompt }], maxTokens: 4096, temperature: 0.2 });
-process.stdout.write(text || '');
-" 2>/tmp/llm-err.log)
-
-if [ -z "$LLM_OUTPUT" ]; then
-  echo "[oneshot] ❌ LLM 没返回"
-  exit 2
-fi
-
-# 4. 解析 diff
-DIFF=$(echo "$LLM_OUTPUT" | python3 -c "
-import sys, re
-text = sys.stdin.read()
-m = re.search(r'\`\`\`diff\s*([\s\S]*?)\`\`\`', text)
-if m:
-    diff = m.group(1).strip()
-    if not diff.endswith('\n'):
-        diff += '\n'
-    print(diff)
-else:
-    sys.exit(1)
-" 2>/dev/null) || {
-  echo "[oneshot] ❌ LLM 输出没 diff 块"
-  echo "--- LLM 原始输出 (前 800) ---"
-  echo "$LLM_OUTPUT" | head -c 800
-  echo ""
-  exit 3
-}
-
-echo "[oneshot] 拿到 diff: $(echo "$DIFF" | wc -l) lines"
-
-# 5. 写 staging
-ID="oneshot-$(date +%s)"
-mkdir -p "staging/auto-evolve/$ID"
-echo "$DIFF" > "staging/auto-evolve/$ID/$ID.patch"
-echo "$ID" > "staging/auto-evolve/$ID/.patch-id"
-echo "[oneshot] patch 写到 staging/auto-evolve/$ID/"
-
-# 6. 跑 reviewer
-echo "[oneshot] 3. 跑 reviewer..."
-npx tsx -r dotenv/config scripts/diff-reviewer.ts "$ID" > /tmp/reviewer.log 2>&1 || true
-VERDICT=$(python3 -c "
-import json
-try:
-    print(json.load(open('staging/auto-evolve/$ID/.review-verdict')).get('verdict','UNKNOWN'))
-except:
-    print('UNKNOWN')
-")
-echo "[oneshot] reviewer verdict: $VERDICT"
-
-# 7. apply + commit
-if [ "$VERDICT" = "PASS" ]; then
-  echo "[oneshot] 4. apply + commit"
-  if git apply --recount --whitespace=fix "staging/auto-evolve/$ID/$ID.patch" 2>/tmp/apply.err; then
-    git add -A
-    git commit -m "auto-evolve: $ID (LLM 修复)"
-    echo "[oneshot] ✅ 提交成功"
-    # 验证
-    npx vitest run --reporter=json --no-color 2>/dev/null > /tmp/vt-after.json
-    AFTER_FAIL=$(python3 -c "
-import json
-print(sum(1 for f in json.load(open('/tmp/vt-after.json')).get('testResults',[]) for a in f.get('assertionResults',[]) if a.get('status')=='failed'))
-")
-    echo "[oneshot] 修复后 fail: $AFTER_FAIL (之前 $TOTAL_FAIL)"
-  else
-    echo "[oneshot] ❌ git apply 失败:"
-    cat /tmp/apply.err
-    exit 4
-  fi
-else
-  echo "[oneshot] ❌ reviewer verdict=$VERDICT, 不 apply"
-  cat /tmp/reviewer.log | head -10
-  exit 5
-fi