@bolloon/bolloon-agent 0.6.5 → 0.6.7

package/dist/web/mobile-agent.js

@@ -10,19 +10,77 @@
  *       agent.info      : 请求/响应 对端 DID 与能力
  *   - 本层只负责"agent 智能", 不碰存储; session 落库由 mobile-core 协调 data 层做.
  */
-// ============ 身份 (WebCrypto) ============
+// ============ 身份 (DIAP KeyManager — @diap/sdk/browser, 与桌面同一套) ============
+// 2026-10-07: 手机端身份改用 @diap/sdk 原生实现 (KeyManager 生成 Ed25519 密钥对 → did:key),
+//   与桌面 agent-identity / x402 签名完全同构: privateKey 32B 种子 + publicKey + did:key:z...
+//   签名走 @noble/ed25519 signAsync (与桌面 ed25519Sign 同结果)。
 const IDENTITY_DB = 'bolloon-mobile';
 let _identity = null;
 // #2 手机自动入网 (browser-safe gateway, 与桌面同一协议): 检测到链接自动 join
 import { mobileAutoJoinGateway } from './mobile-gateway.js';
-async function generateDID() {
-    const bytes = crypto.getRandomValues(new Uint8Array(32));
-    const digest = await crypto.subtle.digest('SHA-256', bytes);
-    return 'did:blln:' + Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, '0')).join('').slice(0, 32);
+// @diap/sdk/browser — KeyManager (密钥生成/DID 派生), @noble/ed25519 — signAsync (签名)
+// 两个都是纯 JS 无 Node 依赖, 浏览器可用。动态 import 避免拖慢首屏。
+let _keyMgr = null;
+let _ed25519 = null;
+async function loadDiap() {
+    if (_keyMgr && _ed25519)
+        return { KeyManager: _keyMgr, ed25519: _ed25519 };
+    const km = await import('@diap/sdk/browser');
+    const ed = await import('@noble/ed25519');
+    _keyMgr = km.KeyManager;
+    _ed25519 = ed;
+    return { KeyManager: km.KeyManager, ed25519: ed };
+}
+function bytesOf(s) {
+    const src = new TextEncoder().encode(s);
+    const out = new Uint8Array(new ArrayBuffer(src.byteLength));
+    out.set(src);
+    return out;
+}
+function bufToHex(buf) {
+    return Array.from(buf).map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+async function sha256Hex(text) {
+    const d = await crypto.subtle.digest('SHA-256', bytesOf(text));
+    return Array.from(new Uint8Array(d)).map((b) => b.toString(16).padStart(2, '0')).join('');
+}
+function b64(buf) {
+    let out = '';
+    for (let i = 0; i < buf.length; i++)
+        out += String.fromCharCode(buf[i]);
+    return btoa(out);
+}
+function b64ToBytes(b64s) {
+    const bin = atob(b64s);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++)
+        out[i] = bin.charCodeAt(i);
+    return out;
+}
+/** 用身份私钥 (32B hex) 签名任意文本 → base64 签名 + 公钥 + DID (与桌面 ed25519Sign 同语义) */
+export async function signWithIdentity(payload) {
+    const id = await ensureIdentity();
+    if (!id.privateKey)
+        throw new Error('identity_signing_unavailable: 本机身份无私钥');
+    const { ed25519 } = await loadDiap();
+    const priv = Uint8Array.from(id.privateKey.match(/.{2}/g).map((h) => parseInt(h, 16)));
+    const sig = await ed25519.signAsync(bytesOf(String(payload ?? '')), priv);
+    return { did: id.did, publicKey: id.publicKey, signature: b64(new Uint8Array(sig)), alg: 'ed25519' };
+}
+/** 验证身份签名 (用身份公钥验) — 与桌面 ed25519Verify 同语义 */
+export async function verifyIdentitySignature(payload, signatureB64, publicKeyHex) {
+    try {
+        const { ed25519 } = await loadDiap();
+        const pub = Uint8Array.from(publicKeyHex.match(/.{2}/g).map((h) => parseInt(h, 16)));
+        return ed25519.verifyAsync(b64ToBytes(signatureB64), bytesOf(String(payload ?? '')), pub);
+    }
+    catch {
+        return false;
+    }
 }
 function openIdentityDb() {
     return new Promise((resolve, reject) => {
-        const req = indexedDB.open(IDENTITY_DB, 1);
+        const req = indexedDB.open(IDENTITY_DB, 2);
         req.onupgradeneeded = () => {
             const db = req.result;
             if (!db.objectStoreNames.contains('kv'))
@@ -80,18 +138,37 @@ export async function loginIdentity(name) {
     _identity = next;
     return { ...next, loggedIn: true };
 }
+/** 更新身份附带条件 (邮箱/手机号/备注) — 只存本机 */
+export async function updateIdentityProfile(partial) {
+    const id = await ensureIdentity();
+    const next = {
+        ...id,
+        name: typeof partial.name === 'string' && partial.name.trim() ? partial.name.trim() : id.name,
+        email: typeof partial.email === 'string' ? partial.email.trim() : id.email,
+        phone: typeof partial.phone === 'string' ? partial.phone.trim() : id.phone,
+        note: typeof partial.note === 'string' ? partial.note.trim() : id.note,
+    };
+    await _kvPut('identity', next);
+    _identity = next;
+    return next;
+}
 /** 注销: 清除登录态 (保留设备 DID, 不影响 P2P/频道) */
 export async function logoutIdentity() {
     await _kvPut('loggedIn', false);
     return { ok: true };
 }
-/** 身份状态 (含登录态; 未登录时 name 置空) */
+/** 身份状态 (含登录态 + 附带条件; 未登录时 name 置空) */
 export async function identityStatus() {
     const id = await ensureIdentity();
     const loggedIn = (await _kvGet('loggedIn')) === true;
-    return { did: id.did, didShort: id.did ? id.did.slice(0, 12) : '', name: loggedIn ? id.name : '', createdAt: id.createdAt, loggedIn };
+    return {
+        did: id.did, didShort: id.did ? id.did.slice(0, 12) : '',
+        name: loggedIn ? id.name : '', createdAt: id.createdAt, loggedIn,
+        publicKey: id.publicKey || '',
+        email: id.email || '', phone: id.phone || '', note: id.note || '',
+    };
 }
-/** 获取本机 DID (首次生成并持久化) */
+/** 获取本机身份 (首次用 DIAP KeyManager 生成 Ed25519 → did:key; 持久化) */
 export async function ensureIdentity() {
     if (_identity)
         return _identity;
@@ -108,7 +185,27 @@ export async function ensureIdentity() {
             _identity = id;
             return id;
         }
-        const fresh = { did: await generateDID(), name: 'blln-mobile', createdAt: Date.now() };
+        // 2026-10-07: 用 @diap/sdk KeyManager 生成 (与桌面同一套) — DID 即公钥指纹, 可签名
+        let kp;
+        try {
+            const { KeyManager } = await loadDiap();
+            kp = KeyManager.generate();
+        }
+        catch (err) {
+            // 老 WebView 加载不了 @diap → 退化为哈希 DID (只读, 无签名)
+            const digest = await sha256Hex(String(Date.now()) + Math.random());
+            const legacy = { did: 'did:blln:' + digest.slice(0, 32), publicKey: '', privateKey: '', name: 'blln-mobile', createdAt: Date.now() };
+            await _kvPut('identity', legacy);
+            _identity = legacy;
+            return legacy;
+        }
+        const fresh = {
+            did: kp.did,
+            publicKey: bufToHex(kp.publicKey),
+            privateKey: bufToHex(kp.privateKey),
+            name: 'blln-mobile',
+            createdAt: Date.now(),
+        };
         await new Promise((resolve, reject) => {
             const tx = db.transaction('kv', 'readwrite');
             tx.objectStore('kv').put(fresh, 'identity');
@@ -119,25 +216,35 @@ export async function ensureIdentity() {
         return fresh;
     }
     catch {
-        const fallback = { did: await generateDID(), name: 'blln-mobile', createdAt: Date.now() };
+        const digest = await sha256Hex(String(Date.now()) + Math.random());
+        const fallback = { did: 'did:blln:' + digest.slice(0, 32), publicKey: '', privateKey: '', name: 'blln-mobile', createdAt: Date.now() };
         _identity = fallback;
         return fallback;
     }
 }
 // ============ LLM 配置 (桌面同步注入 / 手机默认) ============
+// 2026-10-07: 开箱即用 — 手机独立运行时无需任何 API 配置。
+//   内置公共网关 (Cloudflare Worker: api.bolloon.cn) 转发到 GLM 上游;
+//   公共通道每天 ≤500 次/人; 桌面同步注入自己的 key 后自动覆盖。
+const BUILTIN_LLM = Object.freeze({
+    baseUrl: 'https://api.bolloon.cn/v1',
+    apiKey: 'bolloon-free',
+    model: 'glm-5.3',
+    maxTokens: 16384,
+});
 let _llmConfig = null;
 /** 最近一次 runLocalAgent 的执行过程摘要 (每步 onStep 文本), 由 message.send 广播给工作记录 UI */
 let _lastWorklog = [];
 export function getLastWorklog() { return _lastWorklog; }
-/** 注入 LLM 配置 (由 mobile-core 在 data.llm-config.reply 同步后调用) */
+/** 注入 LLM 配置 (由 mobile-core 在 data.llm-config.reply 同步后调用); null = 用内置免费网关 */
 export function setLlmConfig(cfg) {
     _llmConfig = cfg;
     // 立即注入 native bridge (agentConfigure), 让 AgentRuntime 马上可用, 不必等下次 runLocalAgent
     applyLlmConfigToBridge().catch(() => { });
 }
-/** 当前 LLM 配置 (未同步则为 null → 手机默认) */
+/** 当前 LLM 配置 (未同步则返回内置免费网关 → 手机开箱即用) */
 export function getLlmConfig() {
-    return _llmConfig;
+    return _llmConfig || BUILTIN_LLM;
 }
 /** 把配置注入 Capacitor RokidBridge (agentConfigure), 让 Kotlin AgentRuntime 用同步来的 LLM */
 async function applyLlmConfigToBridge() {
@@ -346,8 +453,6 @@ export function formatMobileJoinResult(r) {
 // ============ 本地执行 (Kotlin AgentRuntime / 离线兜底) ============
 /** 手机端本地 agent 执行 (优先 Kotlin, 离线内置规则) */
 export async function runLocalAgent(goal) {
-    const win = typeof window !== 'undefined' ? window : null;
-    const cap = win?.Capacitor;
     // 2026-09-15: 「读入网说明 → 入网」在手机端本地自足执行 (先于 Kotlin 桥: 原生工具集里没有入网能力,
     //   交给它只会得到空转回复)。这样浏览器 / WebView / 真机三种环境行为一致。
     const joinDocUrl = detectJoinDocUrl(goal);
@@ -359,20 +464,22 @@ export async function runLocalAgent(goal) {
         _lastWorklog = [..._lastWorklog, ...r.steps.map((s) => `${s.ok ? '✓' : '✗'} ${s.step}: ${s.note}`)];
         return formatMobileJoinResult(r);
     }
-    const bridge = cap && cap.Plugins && cap.Plugins.RokidBridge;
-    if (bridge && cap.isNativePlatform?.()) {
-        try {
-            await applyLlmConfigToBridge();
-            const r = await bridge.runAgent({ goal });
-            _lastWorklog = (r && Array.isArray(r.worklog)) ? r.worklog.map((x) => String(x)) : [];
-            return r?.result || '（无返回）';
-        }
-        catch (e) {
-            throw new Error('AgentRuntime: ' + String(e?.message || e).slice(0, 60));
-        }
-    }
+    // 普通手机 Agent 永远走 WebView 本地执行链。
+    // Android 无障碍仅适用于未来的跨 App 控制，不得阻塞手机端基础执行；iOS 与 Android 因此行为一致。
     // 内置极简回复 (纯离线可用)
     const t = (goal || '').trim();
+    // 2026-10-07: 手机自治 — 先用 LLM 循环 (经内置公共网关), 失败再降级纯规则
+    //   2026-10-16: silentDegrade=true — LLM 不可达时 → throw → 下面 catch → 内置离线规则,
+    //   (上一层 runWebAgentLoop 若默认返回降级文本, 内置规则层就永远走不到)
+    try {
+        const llm = getLlmConfig();
+        if (llm && llm.baseUrl) {
+            const reply = await runWebAgentLoop(goal, { baseUrl: llm.baseUrl, apiKey: llm.apiKey, model: llm.model, maxTokens: llm.maxTokens }, { silentDegrade: true });
+            if (reply)
+                return reply;
+        }
+    }
+    catch { /* 网络/网关不可达 → 降级内置规则 */ }
     if (t.includes('你好') || t === 'hi' || t === 'hello')
         return '你好! 我是炁球 (Bolloon), 已在手机本地独立运行 (Agent 功能层 + 数据同步层分离)。';
     if (t.includes('身份') || t.includes('did')) {
@@ -407,6 +514,421 @@ export async function runLocalAgent(goal) {
     }
     return `已收到: "${(goal || '').slice(0, 40)}"。这是手机端 Agent 功能层的本地执行 (数据同步与 agent 功能已分离)。`;
 }
+// ============ 手机自治 agent 循环 — 原生运行内核 (2026-10-16) ============
+// 桌面 Kernel 的浏览器移植, 手机原生功能逐项落地 (leo 点名清单):
+//   · memory 设计迭代 + 人际关系分类 (mobile-memory.ts: fact/preference/event/relationship/skill-feedback,
+//     relation{family|friend|work|acquaintance|stranger, trust}, TTL/decay/快照/指纹)
+//   · 错误恢复 (分类 + 退避重试 + 失败反思注入上下文)
+//   · 自适应 API 超时 (按上下文长度: max(10s, ceil(ctxChars/1024)*4000+10000))
+//   · 记忆快照 / bootstrap (启动恢复快照 + 收尾落快照)
+//   · 文档冻结 + 隐式化 (user 文档 / soul 文档只注摘要, 不整篇塞 — leo: 系统 prompt 注入太多, 删)
+//   · 上下文压缩 / 缓存命中 (指纹装配缓存: 同冻结上下文指纹 → 复用 system 不重建)
+//   · 工具指纹 (工具集 hash → 缓存 key, 工具变了 key 变)
+//   · 生命周期 (idle→running→paused(确认)→done/cancelled/error) + TTL
+//   · 多模态通道标注 (text/image/audio/file) + 能动性 (先动手别先问)
+//   · 中间阶段性环境 (已完成步骤注入) + 计划设计 (阶段提示) + 确认模式 (高风险工具)
+//   · task / process 运行记录 (run 记录落 localStorage, 可查)
+// 能力范围: 手机 WebView 能做的 (身份/钱包/入网/P2P/信息查询), 不假装能做 fs/shell。
+// 2026-10-07: persona 注入 — 性格/价值观/兴趣/说话方式来自 mobile-persona (设置 → 性格)。
+import { loadPersona, buildPersonaPrompt } from './mobile-persona.js';
+import { MobileMemory, MobileCache, quickHash } from './mobile-memory.js';
+const runsKey = (did) => `bolloon_mobile_runs_${did}`;
+/** 最近运行记录 (task/process 台账, 手机原生) */
+export function listMobileRuns(did, limit = 20) {
+    try {
+        const raw = typeof localStorage !== 'undefined' ? localStorage.getItem(runsKey(did)) : null;
+        if (!raw)
+            return [];
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed.slice(0, limit) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function saveRunRecord(did, rec) {
+    try {
+        const prev = listMobileRuns(did, 50);
+        const next = [rec, ...prev.filter((r) => r.runId !== rec.runId)].slice(0, 50);
+        if (typeof localStorage !== 'undefined')
+            localStorage.setItem(runsKey(did), JSON.stringify(next));
+    }
+    catch { /* 台账写失败不阻断运行 */ }
+}
+// ── 工具指纹 + 上下文指纹 (缓存命中) ───────────────────────────────────────
+const toolNames = () => Object.keys(WEB_AGENT_TOOLS).sort().join(',');
+let _toolFingerprint = '';
+/** 工具指纹: 工具集 hash (工具变了 → 指纹变 → system 装配缓存 miss) */
+export function toolFingerprint() {
+    if (!_toolFingerprint)
+        _toolFingerprint = quickHash('tools|' + toolNames());
+    return _toolFingerprint;
+}
+const CHANNEL_LABEL = {
+    text: '文字', image: '图片', audio: '语音', file: '文件',
+};
+// ── 确认模式 (高风险工具执行前) ───────────────────────────────────────────
+// 默认空名单 (机制就位; 需要拦的工具由调用方注入 confirm 回调裁决)
+const CONFIRM_REQUIRED_TOOLS = [];
+export function isConfirmRequiredTool(tool) {
+    return CONFIRM_REQUIRED_TOOLS.includes(tool);
+}
+function buildAgentSystem(opts = {}) {
+    const persona = loadPersona();
+    const personaBlock = buildPersonaPrompt(persona);
+    // 文档隐式化 (leo: 系统 prompt 注入太多, 文档可以删):
+    //   user 文档 → 身份/偏好摘要; soul 文档 → persona 摘要 (buildPersonaPrompt 本身就是摘要形)
+    //   完整文档不整篇塞进 prompt, 按需由工具读取。
+    const userBlock = opts.userDoc && opts.userDoc.trim()
+        ? `【用户档案】\n${opts.userDoc.trim().slice(0, 400)}`
+        : '';
+    const memoryBlock = opts.memoryBlock && opts.memoryBlock.trim()
+        ? `【记忆】\n${opts.memoryBlock.trim().slice(0, 600)}`
+        : '';
+    // 稳态记忆块 (对齐桌面 formatMemorySystemBlock, 2026-10-16 补齐): 固化优先 + importance 降序,
+    //   始终注入 system — 不是只靠当轮 query 召回。与 memoryBlock (recall) 互补。
+    const stableBlock = opts.memory && opts.memory.stableBlock
+        ? opts.memory.stableBlock(6)
+        : '';
+    const progressBlock = opts.progress && opts.progress.length
+        ? `【本轮进度】\n已完成: ${opts.progress.slice(-8).map((s, i) => `${i + 1}. ${s.slice(0, 80)}`).join('\n')}`
+        : '';
+    const planHint = opts.plan && opts.plan.trim()
+        ? `【计划】\n${opts.plan.trim().slice(0, 300)}`
+        : '任务复杂时先在内心拆步骤, 逐步执行, 每步用一个工具推进。';
+    const channelBlock = opts.channel && opts.channel !== 'text'
+        ? `【输入通道】\n本次输入是${CHANNEL_LABEL[opts.channel]}。你能理解${CHANNEL_LABEL[opts.channel]}内容并据此回答/执行。`
+        : '';
+    return [
+        '你是手机端 Bolloon 智能体 (自治节点), 用中文简洁回复。',
+        personaBlock,
+        userBlock,
+        memoryBlock,
+        stableBlock,
+        '你有以下工具, 按需调用 (JSON: {"tool":"名字","args":{...}}), 不需要工具就直接回答:',
+        '- get_status: 查本机身份/入网/钱包/连接状态 (args: 无)',
+        '- get_wallet: 查钱包余额 (args: 无)',
+        '- get_identity: 查本机身份证明 (args: 无)',
+        '- get_contacts: 查联系方式授权状态 (args: 无)',
+        '每轮最多用一个工具; 拿到结果后继续思考, 直到任务完成给出最终回答。',
+        progressBlock,
+        planHint,
+        channelBlock,
+        '能动性: 先动手别先问; 做到底 (交付=能用的结果); 一个工具不够就换方式继续; 被阻塞如实说, 不编造。',
+    ].filter(Boolean).join('\n');
+}
+// 2026-10-16: 工具签名带 args (更灵活调用; 现有工具忽略 args)
+const WEB_AGENT_TOOLS = {
+    get_status: async () => {
+        try {
+            const id = await ensureIdentity();
+            return `身份: ${id.did.slice(0, 16)}... 名字: ${id.name}`;
+        }
+        catch (e) {
+            return '身份读取失败: ' + String(e?.message || e).slice(0, 60);
+        }
+    },
+    get_wallet: async () => {
+        try {
+            const id = await ensureIdentity();
+            const w = await import('./mobile-wallet.js');
+            const info = await w.walletForAgent(id.did);
+            if (!info.exists)
+                return '本机没有授权给当前智能体的钱包 (我 → 设置 → 钱包 可创建/授权)。';
+            const w0 = info.wallets[0];
+            let s = `钱包: ${w0.name || w0.id} (${w0.address.slice(0, 12)}...)`;
+            if (w0.unlocked) {
+                try {
+                    s += ` 余额: ${await w.walletBalance(w0.id)}`;
+                }
+                catch {
+                    s += ' 余额: 查询失败';
+                }
+            }
+            else
+                s += ' (未解锁)';
+            return s;
+        }
+        catch (e) {
+            return '钱包查询失败: ' + String(e?.message || e).slice(0, 60);
+        }
+    },
+    get_identity: async () => {
+        const id = await ensureIdentity();
+        return `身份证明: ${id.did} 名字: ${id.name}`;
+    },
+    get_contacts: async () => {
+        try {
+            return '联系方式与授权模块可用 (详见「我 → 联系方式与授权」)。';
+        }
+        catch {
+            return '联系人模块暂不可用';
+        }
+    },
+};
+export function classifyMobileError(err) {
+    const msg = String(err?.message || err?.cause?.message || err || '');
+    if (/timeout|timed out|AbortError|aborted/i.test(msg))
+        return { cls: 'timeout', retryable: true, hint: '请求超时, 稍后重试' };
+    if (/terminated|ECONNRESET|socket hang up|fetch failed|network|ETIMEDOUT|ECONNREFUSED|UND_ERR|Failed to fetch/i.test(msg))
+        return { cls: 'network', retryable: true, hint: '网络波动, 正在重试' };
+    if (/401|403|quota|rate limit|API key|invalid api|HTTP 40\d|HTTP 429/i.test(msg))
+        return { cls: 'api', retryable: false, hint: '接口/配额错误, 无法自动恢复' };
+    return { cls: 'unknown', retryable: true, hint: '未知错误, 尝试继续' };
+}
+/** 自适应 API 超时: max(10s, ceil(ctxChars/1024)*4000 + 10000) — 长上下文不被误杀 (桌面同规则) */
+export function adaptiveTimeoutMs(ctxChars, baseMs = 10_000) {
+    const byLen = Math.ceil(Math.max(0, ctxChars) / 1024) * 4000 + baseMs;
+    return Math.max(baseMs, byLen);
+}
+/** 单轮 LLM 调用 (OpenAI 兼容, 经内置公共网关) — 自适应超时 + 网络错误退避重试 */
+async function webAgentLlmCall(messages, llm) {
+    // 2026-10-15: 网关不可达时**快速降级**而不是挂死 — 公共网关限流/断网时 fetch 可能永久挂起,
+    //   手机端 runLocalAgent 会先走 LLM 再降级内置规则, 挂起 = 测试 20s 超时 + 真机"发消息无反应"。
+    //   自适应超时 (2026-10-16): 短上下文 10s 底线, 长上下文按 4s/1KB 加时, 最坏 150 步有上界又不会误杀长任务。
+    const ctxChars = messages.reduce((n, m) => n + String(m.content || '').length, 0);
+    const timeoutMs = adaptiveTimeoutMs(ctxChars);
+    // 错误恢复: 网络类错误退避重试 (500ms/1500ms, 共 2 次重试); 超时/API 错误不重试 (明确失败)
+    let lastErr = null;
+    for (let attempt = 0; attempt < 3; attempt++) {
+        try {
+            const resp = await fetch(llm.baseUrl.replace(/\/$/, '') + '/chat/completions', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json', 'Authorization': 'Bearer ' + (llm.apiKey || '') },
+                body: JSON.stringify({
+                    model: llm.model || 'glm-5.3',
+                    messages,
+                    max_tokens: llm.maxTokens || 2048,
+                    temperature: 0.4,
+                }),
+                // eslint-disable-next-line no-undef
+                signal: AbortSignal.timeout(timeoutMs),
+            });
+            if (!resp.ok)
+                throw new Error('LLM HTTP ' + resp.status + ': ' + (await resp.text()).slice(0, 120));
+            const data = await resp.json();
+            const content = data?.choices?.[0]?.message?.content;
+            if (!content)
+                throw new Error('LLM 空回复');
+            return String(content).trim();
+        }
+        catch (e) {
+            const cls = classifyMobileError(e);
+            lastErr = e;
+            if (cls.cls === 'timeout' || cls.cls === 'api' || attempt >= 2)
+                throw e; // 明确失败不重试
+            await new Promise((r) => setTimeout(r, attempt === 0 ? 500 : 1500)); // 网络波动退避
+        }
+    }
+    throw lastErr || new Error('LLM 调用失败');
+}
+/**
+ * 宽容提取 LLM 回复里的工具调用 JSON。
+ * 匹配模式: {"tool":"...","args":{...}} — 容忍前置文本、代码块围栏、尾部文本。
+ * 用花括号平衡计数提取完整对象 (非贪婪正则会被内层嵌套 {} 截断 — 模拟器验证踩到)。
+ * 找不到合法 tool 字段返回 null (当作普通回答)。
+ */
+function extractToolCall(raw) {
+    if (!raw)
+        return null;
+    // 1) 直接找第一个 '{"' 开头、括号平衡的完整 JSON 对象
+    const start = raw.indexOf('{"');
+    if (start >= 0) {
+        try {
+            const obj = parseBalancedJson(raw, start);
+            if (obj && typeof obj.tool === 'string') {
+                return { tool: obj.tool, args: (obj.args && typeof obj.args === 'object' ? obj.args : {}) };
+            }
+        }
+        catch { /* 不是 JSON, 继续 */ }
+    }
+    // 2) 代码块围栏内的 JSON (```json ... ```)
+    const fm = /```(?:json)?\s*([\s\S]*?)```/.exec(raw);
+    if (fm) {
+        try {
+            const obj = JSON.parse(fm[1]);
+            if (obj && typeof obj.tool === 'string') {
+                return { tool: obj.tool, args: (obj.args && typeof obj.args === 'object' ? obj.args : {}) };
+            }
+        }
+        catch { /* 忽略 */ }
+    }
+    return null;
+}
+/** 从 start 位置解析一个括号平衡的 JSON 对象 (容忍内部嵌套字符串/大括号) */
+function parseBalancedJson(raw, start) {
+    if (raw[start] !== '{')
+        throw new Error('not object');
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = start; i < raw.length; i++) {
+        const ch = raw[i];
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (ch === '"')
+                inString = false;
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            continue;
+        }
+        if (ch === '{')
+            depth++;
+        else if (ch === '}') {
+            depth--;
+            if (depth === 0)
+                return JSON.parse(raw.slice(start, i + 1));
+        }
+    }
+    throw new Error('unbalanced');
+}
+export async function runWebAgentLoop(goal, llm, opts = {}) {
+    // ── bootstrap ─────────────────────────────────────────────────────────────
+    const id = await ensureIdentity();
+    const did = id.did;
+    const memory = opts.memory || new MobileMemory(did);
+    memory.restore(memory.snapshot()); // 启动恢复记忆 (幂等: restore 只合并缺失条目)
+    const channel = opts.channel || 'text';
+    const runId = quickHash(did + '|' + goal + '|' + Date.now());
+    // task/process 记录: 生命周期开始
+    const record = { runId, goal: String(goal || '').slice(0, 80), status: 'running', steps: 0, startedAt: new Date().toISOString(), channel };
+    saveRunRecord(did, record);
+    // 文档冻结 + 隐式化 (leo: 系统 prompt 注入太多, 文档可以删):
+    //   userDoc 缺省 = 身份 profile 摘要; soulDoc 缺省 = persona 摘要 (buildAgentSystem 内取)
+    const userDoc = opts.userDoc ?? ([id.name ? `名字: ${id.name}` : '', id.phone ? `手机号: ${id.phone}` : '', id.email ? `邮箱: ${id.email}` : '', id.note ? `备注: ${id.note}` : '']
+        .filter(Boolean).join('\n'));
+    // memory 整段注入: 按目标召回 (冻结快照, 循环内不重建 → 缓存命中稳定)
+    const memoryBlock = memory.recall(String(goal || ''), { limit: 3 }).map((e) => e.content).join('\n');
+    // 缓存命中: system 装配指纹 = 冻结上下文摘要 + 工具指纹 + 目标前缀
+    //   同指纹 (文档/记忆/工具没变) → 复用 system, 不重建 (桌面 kv-prefix-cache 同原理)
+    const sysCache = new MobileCache('bolloon_sys');
+    // 稳态记忆块参与指纹: 固化记忆变了 → 指纹变 → system 重建 (memory 文档冻结与失效对齐)
+    const stableFp = memory.stableBlock(6);
+    const sysFp = quickHash([
+        userDoc, opts.soulDoc || 'soul-default', memoryBlock, stableFp, toolFingerprint(), channel, opts.plan || '',
+    ].join('|'));
+    const messages = [
+        { role: 'system', content: sysCache.get(sysFp, 10 * 60_000) || buildAgentSystem({ goal, memoryBlock, userDoc, soulDoc: opts.soulDoc, channel, plan: opts.plan, memory }) },
+        { role: 'user', content: String(goal || '') },
+    ];
+    sysCache.set(sysFp, messages[0].content); // 冻结 system 进缓存 (TTL 10min)
+    const MAX_STEPS = 150;
+    const NO_PROGRESS_LIMIT = 10; // 同一工具+参数连续 N 轮 → 死循环
+    const COMPACT_AT = 30; // 消息超过 N 条 → 压缩中间轮
+    const steps = [];
+    let lastToolSig = '';
+    let noProgress = 0;
+    for (let i = 0; i < MAX_STEPS; i++) {
+        // 生命周期: 外部取消 → cancelled
+        if (opts.signal?.aborted) {
+            record.status = 'cancelled';
+            record.finishedAt = new Date().toISOString();
+            saveRunRecord(did, record);
+            _lastWorklog = [...steps, '⚠ 已取消'];
+            return `[手机自治执行 ${steps.length} 步 · 已取消]`;
+        }
+        let raw;
+        try {
+            raw = await webAgentLlmCall(messages, llm);
+        }
+        catch (e) {
+            // 错误恢复: LLM 调用失败 → 记录 error 生命周期 + 降级
+            const hint = classifyMobileError(e).hint;
+            record.status = 'error';
+            record.error = String(e?.message || e).slice(0, 120);
+            record.finishedAt = new Date().toISOString();
+            saveRunRecord(did, record);
+            _lastWorklog = [...steps, `⚠ ${hint}`];
+            // 0 步就失败 + silentDegrade → 抛错让调用方降级 (runLocalAgent 的 catch → 本地内置规则);
+            //   否则 (自治调用默认) 返回降级文本: 0 步 → 短提示, 已执行 N 步 → 部分成果摘要, 不让用户丢已完成的步骤。
+            if (!steps.length && opts.silentDegrade)
+                throw e;
+            if (!steps.length)
+                return `(${hint}, 请稍后重试)`;
+            return `[手机自治执行 ${steps.length} 步 · ${hint}]\n已完成的步骤结果如下:\n${steps.join('\n')}\n(${hint}, 请稍后重试)`;
+        }
+        // 2026-10-07 (模拟器验证发现): LLM 常输出前置文本+JSON ("好的，我先查询...\n{\"tool\":...}")
+        //   旧正则要求整段是 JSON → 工具调用被当普通回答, 闭环断。宽容提取第一个 JSON 对象。
+        const toolJson = extractToolCall(raw);
+        if (toolJson && typeof toolJson.tool === 'string' && WEB_AGENT_TOOLS[toolJson.tool]) {
+            // 无进展检测 (leo 2026-10-14: 不用超时截止任务周期, 任务该做多久做多久 —
+            //   但连续重复同一动作不放行, 由无进展兜底决定什么时候算完)
+            const sig = toolJson.tool + '|' + JSON.stringify(toolJson.args || {});
+            noProgress = (sig === lastToolSig) ? noProgress + 1 : 0;
+            lastToolSig = sig;
+            if (noProgress >= NO_PROGRESS_LIMIT) {
+                record.status = 'done';
+                record.finishedAt = new Date().toISOString();
+                saveRunRecord(did, record);
+                _lastWorklog = [...steps, `⚠ 连续 ${NO_PROGRESS_LIMIT} 轮重复同一工具调用 (${toolJson.tool}), 判断死循环提前停止`];
+                return `[手机自治执行 ${steps.length} 步 · 检测到重复动作提前停止]\n` + raw.slice(0, 200);
+            }
+            // 确认模式: 高风险工具 → paused → confirm 回调裁决 (拒绝 = 跳过执行, 结果如实告知)
+            if (isConfirmRequiredTool(toolJson.tool)) {
+                const allow = opts.confirm ? await opts.confirm(toolJson.tool, toolJson.args) : false;
+                if (!allow) {
+                    const denied = `工具 ${toolJson.tool} 需要确认, 本次未执行 (请用户批准后重试)。`;
+                    steps.push(`🔒 ${toolJson.tool} → ${denied}`);
+                    messages.push({ role: 'assistant', content: raw });
+                    messages.push({ role: 'user', content: `工具结果: ${denied}` });
+                    continue;
+                }
+            }
+            // 工具执行 (带 args — 更灵活调用)
+            const out = await WEB_AGENT_TOOLS[toolJson.tool](toolJson.args || {});
+            steps.push(`🔧 ${toolJson.tool} → ${out.slice(0, 80)}`);
+            record.steps = steps.length;
+            saveRunRecord(did, record);
+            // 中间阶段性环境: 回调 (UI 进度)
+            if (opts.onProgress) {
+                try {
+                    opts.onProgress({ step: steps.length, tool: toolJson.tool, output: out.slice(0, 120) });
+                }
+                catch { /* 回调失败不影响循环 */ }
+            }
+            if (steps.length > 60)
+                steps.splice(0, steps.length - 60); // 摘要只留最近 60 条, 不无限涨
+            messages.push({ role: 'assistant', content: raw });
+            messages.push({ role: 'user', content: `工具结果: ${out}` });
+            // 上下文压缩: 超过阈值 → 中间轮压成一条摘要 (system + 目标 + 最近 K 轮保留)
+            if (messages.length > COMPACT_AT) {
+                const keep = messages.slice(0, 2);
+                const recent = messages.slice(-10);
+                const summary = `（中间 ${messages.length - 12} 轮对话已压缩）已完成步骤: ${steps.slice(-12).map((s) => s.slice(0, 60)).join(' | ')}`;
+                keep.push({ role: 'user', content: summary });
+                messages.length = 0;
+                messages.push(...keep, ...recent);
+            }
+            continue;
+        }
+        // 无工具调用 = 最终回答 → 记忆迭代 (新事实/偏好/关系入库) + 快照落盘 + done
+        memory.autoIterate({ goal: String(goal || ''), toolResults: steps, reply: raw, source: 'session' });
+        memory.snapshot(); // 记忆快照: 收尾落盘 (bootstrap 下次恢复)
+        record.status = 'done';
+        record.finishedAt = new Date().toISOString();
+        saveRunRecord(did, record);
+        _lastWorklog = steps.length ? [...steps, `💬 ${raw.slice(0, 60)}`] : [`💬 ${raw.slice(0, 60)}`];
+        if (steps.length)
+            return `[手机自治执行 ${steps.length} 步]\n` + raw;
+        return raw;
+    }
+    // 循环保护: 没收敛就给最后一条 (生命周期 done)
+    const last = messages[messages.length - 1]?.content || '';
+    record.status = 'done';
+    record.finishedAt = new Date().toISOString();
+    saveRunRecord(did, record);
+    _lastWorklog = [...steps, '⚠ 达到步数上限, 已停止'];
+    return `[手机自治执行, 达到 ${MAX_STEPS} 步上限]\n${last.slice(0, 200)}`;
+}
 let _send = null;
 let _ownDid = '';
 const replyHandlers = new Set();
@@ -537,31 +1059,33 @@ export async function runPhoneAgent(goal) {
     const id = await ensureIdentity();
     try {
         if (native) {
-            await applyLlmConfigToBridge();
-            const r = await bridge.runAgent({ goal });
-            const result = r?.result || '（无返回）';
-            const isDone = /^DONE:/.test(result) || /^CANCELLED/.test(result) || !/^(MAX_STEPS|STOPPED|\[Agent 异常)/.test(result);
-            return {
-                ok: !/^\[Agent 异常|^STOPPED|^MAX_STEPS/.test(result),
-                goal,
-                result,
-                did: id.did,
-                mode: 'native',
-                agentId: r?.agentId,
-                stepCount: r?.stepCount,
-            };
+            const st = await bridge.agentStatus?.();
+            if (st?.accessibilityReady !== false) {
+                await applyLlmConfigToBridge();
+                const r = await bridge.runAgent({ goal });
+                const result = r?.result || '（无返回）';
+                return {
+                    ok: !/^\[Agent 异常|^STOPPED|^MAX_STEPS/.test(result),
+                    goal,
+                    result,
+                    did: id.did,
+                    mode: 'native',
+                    agentId: r?.agentId,
+                    stepCount: r?.stepCount,
+                };
+            }
         }
         // 离线 fallback: 内置规则 (不依赖 LLM/原生执行能力, 手机仍自治可用)
         const reply = await runLocalAgent(goal);
         return {
             ok: true, goal, result: reply, did: id.did, mode: 'fallback',
-            hint: '当前是「手机本地规则」模式：这台手机上还没接原生执行能力，所以只能用内置规则回复。连上电脑端后，任务可以交给电脑端 Agent 真正执行。',
+            hint: '当前使用手机本地 Agent；Android/iOS 均可直接执行手机端任务。',
         };
     }
     catch (e) {
         return {
             ok: false, goal, error: String(e?.message || e).slice(0, 100), did: id.did, mode: native ? 'native' : 'fallback',
-            hint: '任务没跑起来。常见原因：① 电脑端没在运行或不同网段 (设置 → 电脑端同步 里配置/测试) ② 没配 LLM API (设置 → API 配置) ③ 这台手机没接原生执行能力。',
+            hint: '任务没跑起来。请先检查「我 → 设置 → API 配置」中的 baseUrl、apiKey 和 model。',
         };
     }
 }
@@ -583,12 +1107,15 @@ export async function phoneStatus() {
         }
         catch { /* 忽略 */ }
     }
+    const capabilities = ['chat', 'local-agent'];
+    if (!native || accReady)
+        capabilities.push('phone-control');
     return {
         ok: true,
         did: id.did,
         mode: native ? 'native' : 'fallback',
         llm,
-        capabilities: ['chat', 'local-agent', 'phone-control'],
+        capabilities,
     };
 }
 /** 取消当前手机 Agent 任务 (phone.agent.cancel) */
@@ -639,4 +1166,4 @@ export async function handleIncomingPhoneMessage(type, payload, fromPeer) {
     }
     catch { /* 控制消息处理失败静默 */ }
 }
-export default { ensureIdentity, loginIdentity, logoutIdentity, identityStatus, runLocalAgent, setAgentTransport, onAgentReply, callRemoteAgent, handleIncomingAgentMessage, notifyAgentReply, onInboundChat, setLlmConfig, getLlmConfig, runPhoneAgent, phoneStatus, cancelPhoneAgent, handleIncomingPhoneMessage };
+export default { ensureIdentity, loginIdentity, logoutIdentity, identityStatus, runLocalAgent, setAgentTransport, onAgentReply, callRemoteAgent, handleIncomingAgentMessage, notifyAgentReply, onInboundChat, setLlmConfig, getLlmConfig, runPhoneAgent, phoneStatus, cancelPhoneAgent, handleIncomingPhoneMessage, runWebAgentLoop };