@bolloon/bolloon-agent 0.6.5 → 0.6.7

package/dist/ios/mobile-memory.js

@@ -0,0 +1,317 @@
+const memKey = (agentId) => `bolloon_mobile_memory_${agentId}`;
+/** 轻量 hash (记忆指纹/条目 id, 不涉密) */
+export function quickHash(text) {
+    let h = 2166136261;
+    for (let i = 0; i < String(text || '').length; i++) {
+        h ^= String(text || '').charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return (h >>> 0).toString(36) + '_' + String(text || '').length.toString(36);
+}
+export function validMemoryContent(content) {
+    return String(content || '').trim().length >= 2;
+}
+/** importance 启发式 (与桌面同口径): 长度 + 强语义词 + kind 加权 */
+export function heuristicImportance(content, kind = 'fact') {
+    const t = String(content || '');
+    let score = 0.3;
+    if (t.length > 100)
+        score += 0.2;
+    if (/喜欢|偏好|讨厌|禁止|必须|永远|从不|重要|注意|记住|约定|家人|朋友|同事/.test(t))
+        score += 0.25;
+    if (kind === 'preference' || kind === 'relationship')
+        score += 0.2;
+    if (kind === 'skill-feedback')
+        score += 0.15;
+    return Math.min(1, score);
+}
+/** 人际关系分类: 从文本/来源推断 relation kind (规则启发式; 未知 = stranger) */
+export function classifyRelation(text, source = '') {
+    const t = String(text || '').toLowerCase();
+    const src = String(source || '').toLowerCase();
+    if (/家人|妈妈|爸爸|母亲|父亲|儿子|女儿|老婆|老公|妻子|丈夫|兄弟|姐妹/.test(t))
+        return 'family';
+    if (/同事|客户|供应商|老板|领导|下属|同事|合作/.test(t))
+        return 'work';
+    if (/朋友|好友|哥们|闺蜜|兄弟|认识的人/.test(t))
+        return 'friend';
+    if (/directory|phone|手机号|通讯录/.test(src))
+        return 'acquaintance';
+    return 'stranger';
+}
+/**
+ * 手机记忆库 (localStorage 持久化; 内存缓存避免每次读盘)。
+ * 测试注入 fake localStorage (mobile-core.test 模式) 即可用。
+ */
+export class MobileMemory {
+    agentId;
+    entries = [];
+    loaded = false;
+    constructor(agentId) {
+        this.agentId = String(agentId || '');
+    }
+    key() { return memKey(this.agentId); }
+    readAll() {
+        try {
+            const raw = typeof localStorage !== 'undefined' ? localStorage.getItem(this.key()) : null;
+            if (!raw)
+                return [];
+            const parsed = JSON.parse(raw);
+            return Array.isArray(parsed) ? parsed : [];
+        }
+        catch {
+            return [];
+        }
+    }
+    writeAll(list) {
+        try {
+            if (typeof localStorage !== 'undefined')
+                localStorage.setItem(this.key(), JSON.stringify(list.slice(-200)));
+        }
+        catch { /* 写失败静默 (内存态仍可用) */ }
+    }
+    ensureLoaded() {
+        if (!this.loaded) {
+            this.entries = this.readAll();
+            this.loaded = true;
+        }
+    }
+    /** 全部条目 (内部用) */
+    all() { this.ensureLoaded(); return [...this.entries]; }
+    /** 落一条记忆 (幂等: 同 id 覆盖); 返回条目 */
+    remember(input) {
+        this.ensureLoaded();
+        const content = String(input.content || '').trim();
+        const source = input.source || 'session';
+        if (!validMemoryContent(content)) {
+            // 空内容拒绝存 (与桌面 validContent 同口径)
+            const id = quickHash(this.agentId + '|' + content || 'empty');
+            const stub = { id, agentId: this.agentId, content: content || '（空）', kind: input.kind || 'fact', importance: 0, createdAt: new Date().toISOString(), updatedAt: new Date().toISOString(), source, recallCount: 0 };
+            return stub;
+        }
+        const kind = input.kind || 'fact';
+        const now = new Date().toISOString();
+        const id = quickHash(this.agentId + '|' + content);
+        const importance = typeof input.importance === 'number'
+            ? Math.min(1, Math.max(0, input.importance))
+            : heuristicImportance(content, kind);
+        const entry = {
+            id, agentId: this.agentId, content, kind,
+            importance, createdAt: now, updatedAt: now,
+            source,
+            ttlMs: input.ttlMs, decayed: false, crystallized: false,
+            recallCount: 0,
+            ...(kind === 'relationship' && input.relation ? { relation: input.relation } : {}),
+        };
+        const idx = this.entries.findIndex((e) => e.id === id);
+        if (idx >= 0) {
+            const prev = this.entries[idx];
+            this.entries[idx] = { ...prev, ...entry, createdAt: prev.createdAt, recallCount: prev.recallCount, crystallized: prev.crystallized || entry.importance >= 0.8 };
+            if (input.relation && prev.relation) {
+                // 关系记忆迭代: 信任度按新信息移动 (平均值), 分类按最新文本重判
+                this.entries[idx].relation = {
+                    did: input.relation.did || prev.relation.did,
+                    kind: input.relation.kind || prev.relation.kind,
+                    trust: Math.min(1, Math.max(0, (prev.relation.trust + input.relation.trust) / 2)),
+                };
+            }
+        }
+        else {
+            this.entries.push(entry);
+        }
+        this.writeAll(this.entries);
+        return this.entries.find((e) => e.id === id) || entry;
+    }
+    /** 召回: 关键词 + importance 加权; 命中即 +1 recallCount + 刷新 lastRecalledAt (迭代) */
+    recall(query, opts = {}) {
+        this.ensureLoaded();
+        this.applyTtl();
+        const q = String(query || '').toLowerCase();
+        const limit = opts.limit ?? 3;
+        const minScore = opts.minScore ?? 0;
+        const scored = [];
+        for (const e of this.entries) {
+            if (e.decayed)
+                continue;
+            const c = String(e.content || '').toLowerCase();
+            let s = e.importance * 0.5;
+            const qTokens = q.split(/\s+/).filter((t) => t.length >= 2);
+            const hit = qTokens.filter((t) => c.includes(t)).length;
+            if (hit > 0)
+                s += 0.3 * (hit / Math.max(qTokens.length, 1));
+            if (qTokens.length && qTokens.some((t) => c.includes(t)))
+                s += 0.2; // 部分命中
+            if (e.relation && e.relation.trust >= 0.7)
+                s += 0.1; // 高信任关系记忆加权
+            if (s >= minScore)
+                scored.push({ e, s });
+        }
+        scored.sort((a, b) => b.s - a.s);
+        const hits = scored.slice(0, limit).map((x) => x.e);
+        for (const h of hits) {
+            const now = new Date().toISOString();
+            h.recallCount += 1;
+            h.lastRecalledAt = now;
+            if (h.recallCount >= 3)
+                h.crystallized = true; // 多次召回 → 固化 (不 decay)
+        }
+        if (hits.length)
+            this.writeAll(this.entries);
+        return hits;
+    }
+    /** TTL 过期 → decayed (不删, 与桌面 applyDecay 同精神) */
+    applyTtl(nowIso) {
+        this.ensureLoaded();
+        const now = Date.parse(nowIso || new Date().toISOString());
+        let changed = false;
+        for (const e of this.entries) {
+            if (e.decayed || e.crystallized || !e.ttlMs)
+                continue;
+            const base = Date.parse(e.lastRecalledAt || e.createdAt) || now;
+            if (now - base > e.ttlMs) {
+                e.decayed = true;
+                changed = true;
+            }
+        }
+        if (changed)
+            this.writeAll(this.entries);
+    }
+    /**
+     * 记忆迭代 (每轮循环后调用): 从「用户目标 + 工具结果 + 最终回复」提炼
+     * 新事实 / 偏好 / 关系。规则启发式 (零 LLM 成本): 信号词命中即存,
+     * 已经存过的同内容自动合并 (remember 幂等)。
+     */
+    autoIterate(input) {
+        this.ensureLoaded();
+        const parts = [String(input.goal || ''), ...(input.toolResults || []), String(input.reply || '')];
+        const text = parts.filter(Boolean).join('\n');
+        if (!text.trim())
+            return 0;
+        let added = 0;
+        // ① 偏好记忆 — 兼容「我/用户/本人」主语 (agent 转述用户原话时主语可能是「用户」)
+        const pref = text.match(/(?:我|用户|本人)(?:喜欢|偏好|热爱|想要|希望).{2,40}?/g);
+        if (pref) {
+            for (const m of pref.slice(0, 3)) {
+                const content = m.replace(/^(?:我|用户|本人)/, '').trim();
+                if (validMemoryContent(content)) {
+                    this.remember({ content: '偏好: ' + content, kind: 'preference', source: input.source || 'iterate' });
+                    added++;
+                }
+            }
+        }
+        // ② 禁忌/约定记忆 — 兼容「不要/不能/别」开头 (用户约束)
+        const ban = text.match(/不要(?:再)?.{2,40}?|不要.{2,40}?|不能.{2,40}?|禁止.{2,40}?|记住.{2,40}?/g);
+        if (ban) {
+            for (const m of ban.slice(0, 2)) {
+                if (validMemoryContent(m)) {
+                    this.remember({ content: '约定: ' + m.trim(), kind: 'insight', source: input.source || 'iterate', importance: 0.6 });
+                    added++;
+                }
+            }
+        }
+        // ③ 关系记忆: 出现「人名/称谓 + 关系词」→ 分类存 (含「同事/合作伙伴」等职场关系)
+        const relMatch = text.match(/([一-龥]{2,6})是(?:我的)?(家人|妈妈|爸爸|老婆|老公|朋友|同事|客户|老板|领导|兄弟|姐妹|妻子|丈夫|合作伙伴)/);
+        if (relMatch) {
+            const name = relMatch[1];
+            const kind = classifyRelation(relMatch[0], input.source || '');
+            const content = `${name} 是${relMatch[2]}`;
+            this.remember({
+                content, kind: 'relationship', source: input.source || 'iterate',
+                importance: 0.8,
+                relation: { did: '', kind, trust: 0.6 },
+            });
+            added++;
+        }
+        return added;
+    }
+    /** 快照 (run 结束/重启恢复用) */
+    snapshot() {
+        this.ensureLoaded();
+        this.applyTtl();
+        return { version: 1, agentId: this.agentId, entries: [...this.entries], savedAt: new Date().toISOString() };
+    }
+    /** 从快照恢复 (bootstrap) — 合并, 不覆盖已有 */
+    restore(snap) {
+        if (!snap || !Array.isArray(snap.entries))
+            return;
+        this.ensureLoaded();
+        for (const e of snap.entries) {
+            const exists = this.entries.some((x) => x.id === e.id);
+            if (!exists)
+                this.entries.push(e);
+        }
+        this.writeAll(this.entries);
+    }
+    /**
+     * 稳态记忆块: 固化优先 + 未淡化 + importance 降序, 始终注入 system。
+     * 与 recall(query) 互补: recall 是即时相关, stableBlock 是用户确认/多次命中的事实。
+     */
+    stableBlock(maxEntries = 6) {
+        this.ensureLoaded();
+        this.applyTtl();
+        const picked = this.entries
+            .filter((e) => !e.decayed)
+            .sort((a, b) => {
+            if (a.crystallized !== b.crystallized)
+                return a.crystallized ? -1 : 1;
+            return b.importance - a.importance;
+        })
+            .slice(0, maxEntries);
+        if (!picked.length)
+            return '';
+        const lines = picked.map((e) => {
+            const tag = `${e.kind}${e.crystallized ? '★' : ''}`;
+            return `- (${tag}, ${e.importance.toFixed(2)}) ${e.content.slice(0, 120)}`;
+        });
+        return `<stable-memory>\n${lines.join('\n')}\n</stable-memory>`;
+    }
+    /** 记忆指纹: 摘要 hash (参与上下文缓存 key; 记忆变了 → 指纹变 → 缓存 miss) */
+    fingerprint() {
+        this.ensureLoaded();
+        this.applyTtl();
+        const active = this.entries.filter((e) => !e.decayed).sort((a, b) => a.id.localeCompare(b.id));
+        const digest = active.slice(-30).map((e) => `${e.kind}:${e.content.slice(0, 60)}:${e.importance.toFixed(2)}`).join('|');
+        return quickHash(digest);
+    }
+}
+/** 独立缓存助手 (mobile-runtime 用): 指纹 → 结果, 带 TTL */
+export class MobileCache {
+    prefix;
+    constructor(prefix = 'bolloon_mobile_cache') { this.prefix = prefix; }
+    get(key, ttlMs = 60_000) {
+        try {
+            const raw = typeof localStorage !== 'undefined' ? localStorage.getItem(`${this.prefix}_${key}`) : null;
+            if (!raw)
+                return null;
+            const parsed = JSON.parse(raw);
+            if (!parsed || !parsed.v || typeof parsed.at !== 'number')
+                return null;
+            if (Date.now() - parsed.at > ttlMs)
+                return null; // TTL 过期 → miss
+            return parsed.v;
+        }
+        catch {
+            return null;
+        }
+    }
+    set(key, value) {
+        try {
+            if (typeof localStorage !== 'undefined')
+                localStorage.setItem(`${this.prefix}_${key}`, JSON.stringify({ v: value, at: Date.now() }));
+        }
+        catch { /* 缓存写失败静默 */ }
+    }
+    clear() {
+        try {
+            const keys = [];
+            for (let i = 0; i < localStorage.length; i++) {
+                const k = localStorage.key(i);
+                if (k && k.startsWith(this.prefix))
+                    keys.push(k);
+            }
+            for (const k of keys)
+                localStorage.removeItem(k);
+        }
+        catch { /* 忽略 */ }
+    }
+}

package/dist/ios/mobile-orbitdb.js

@@ -0,0 +1,194 @@
+let _orbit = null;
+let _node = null;
+/** 当前 OrbitDB 实例 (null = 未创建) */
+export function getMobileOrbitDB() { return _orbit; }
+/** 当前绑定的 helia 节点 (null = 未创建) */
+export function getMobileOrbitNode() { return _node; }
+/** 测试用: 重置实例 (不 stop 节点, 由调用方管) */
+export function resetMobileOrbitDB() {
+    _orbit = null;
+    _node = null;
+}
+/**
+ * 创建手机端 OrbitDB (幂等)。
+ * 需要带 pubsub (gossipsub) 的 helia 节点 —— OrbitDB 4.x 的同步协议靠
+ * ipfs.libp2p.services.pubsub.addEventListener/subscribe。
+ * 不带 pubsub 的节点 (SDK 默认只启 identify) → open store 会抛
+ * "Cannot read properties of undefined (reading 'addEventListener')"。
+ * @returns { ok, orbit?, error? }
+ */
+export async function createMobileOrbitDB(node) {
+    if (_orbit)
+        return { ok: true, orbit: _orbit };
+    try {
+        const activeNode = node ?? _node ?? null;
+        if (!activeNode)
+            return { ok: false, error: '需要 helia 节点 (先 startMobileHelia)' };
+        _node = activeNode;
+        // 动态 import @orbitdb/core (browser bundle; 避免顶层拖慢首屏)
+        const orbitMod = await import('@orbitdb/core');
+        // @orbitdb/core 的 browser bundle 类型导出不稳定 → 显式收成 any (运行时仍是同一函数)
+        const createOrbitDB = orbitMod.default ?? orbitMod.createOrbitDB;
+        if (typeof createOrbitDB !== 'function')
+            return { ok: false, error: '@orbitdb/core 没有 createOrbitDB 导出' };
+        // 用 MemoryStorage (浏览器无 fs) — KeyStore/日志都在内存
+        const orbit = await createOrbitDB({
+            ipfs: activeNode,
+            // 浏览器安全: 全部内存, 不落盘 (真持久化靠 IPFS 网络)
+            directory: undefined,
+        });
+        _orbit = orbit;
+        return { ok: true, orbit };
+    }
+    catch (e) {
+        return { ok: false, error: `创建 OrbitDB 失败: ${String(e?.message || e).slice(0, 200)}` };
+    }
+}
+/**
+ * 用带 pubsub 的节点创建 OrbitDB。
+ * 内部: 若当前节点没有 services.pubsub, 则用 mobile-helia 高级路径 (libp2pOptions + gossipsub)
+ * 重建一个, 替换当前节点。返回重建结果。
+ */
+export async function createMobileOrbitDBWithPubsub(heliaMod) {
+    try {
+        const mh = heliaMod || (await import('./mobile-helia.js'));
+        // 先试现有节点 (可能已有 pubsub)
+        if (_node) {
+            const hasPubsub = !!(_node?.libp2p?.services?.pubsub);
+            if (hasPubsub) {
+                const r = await createMobileOrbitDB(_node);
+                return { ok: r.ok, orbit: r.orbit, node: _node, error: r.error };
+            }
+        }
+        // 没有 pubsub → 用 gossipsub 重建节点 (高级路径)
+        // 注意: buildCustomHelia 的 services 是 identify+ping(+dht), libp2pOptions 整体展开会覆盖 services
+        // → 必须带上 identify/ping 一起, 否则 circuit-relay transport 报 UnmetServiceDependenciesError
+        const { gossipsub } = await import('@libp2p/gossipsub');
+        const { identify } = await import('@libp2p/identify');
+        const { ping } = await import('@libp2p/ping');
+        const nodeR = await mh.createMobileHeliaNode({
+            libp2pOptions: {
+                services: {
+                    identify: identify(), ping: ping(),
+                    // allowPublishToZeroPeers: 单节点/刚启动时没有对端订阅也允许发布 (OrbitDB 4.x 同步需要);
+                    // emitSelf: 自己发布的也回放给自己 (本地 store 一致性)
+                    pubsub: gossipsub({ emitSelf: false, allowPublishToZeroTopicPeers: true }),
+                },
+            },
+        });
+        if (!nodeR.ok || !nodeR.node)
+            return { ok: false, error: nodeR.error || '重建带 pubsub 的节点失败' };
+        const r = await createMobileOrbitDB(nodeR.node);
+        return { ok: r.ok, orbit: r.orbit, node: nodeR.node, error: r.error };
+    }
+    catch (e) {
+        return { ok: false, error: `创建带 pubsub 的 OrbitDB 失败: ${String(e?.message || e).slice(0, 200)}` };
+    }
+}
+/** 打开 store (type: 'keyvalue' | 'documents' | 'events') */
+export async function openStore(name, type = 'keyvalue', options = {}) {
+    try {
+        if (!_orbit) {
+            const r = await createMobileOrbitDB();
+            if (!r.ok)
+                return { ok: false, error: r.error };
+        }
+        const store = await _orbit.open(String(name || ''), { type, ...options });
+        return { ok: true, store };
+    }
+    catch (e) {
+        return { ok: false, error: `打开 store 失败: ${String(e?.message || e).slice(0, 200)}` };
+    }
+}
+/** kvstore: put */
+export async function kvPut(store, key, value) {
+    try {
+        await store.put(String(key), value);
+        return { ok: true };
+    }
+    catch (e) {
+        return { ok: false, error: String(e?.message || e) };
+    }
+}
+/** kvstore: get */
+export async function kvGet(store, key) {
+    try {
+        return { ok: true, value: await store.get(String(key)) };
+    }
+    catch (e) {
+        return { ok: false, error: String(e?.message || e) };
+    }
+}
+/** kvstore: del */
+export async function kvDel(store, key) {
+    try {
+        await store.del(String(key));
+        return { ok: true };
+    }
+    catch (e) {
+        return { ok: false, error: String(e?.message || e) };
+    }
+}
+/** kvstore: 全部条目 */
+export async function kvAll(store) {
+    try {
+        // @orbitdb/core 4.x kvstore: all() 返回 [{key, value, hash}] 数组
+        let all = {};
+        if (typeof store.all === 'function') {
+            const rows = (await store.all()) || [];
+            if (Array.isArray(rows)) {
+                for (const r of rows) {
+                    if (r && r.key !== undefined)
+                        all[String(r.key)] = r.value;
+                }
+            }
+            else if (typeof rows === 'object') {
+                all = rows;
+            }
+        }
+        else if (store.iterator) {
+            for (const [k, v] of (await store.iterator().collect())) {
+                if (k !== undefined)
+                    all[String(k)] = v;
+            }
+        }
+        return { ok: true, entries: all };
+    }
+    catch (e) {
+        return { ok: false, error: String(e?.message || e) };
+    }
+}
+/** documents: 按索引查 (query(fn) — @orbitdb/core 4.x documents 的正确 API; indexBy 在 open 时声明) */
+export async function docQuery(store, query) {
+    try {
+        let r;
+        if (typeof query === 'function') {
+            r = await store.query(query);
+        }
+        else if (query && typeof query === 'object') {
+            // 对象查询 → 转成匹配所有键值的函数 (与 indexBy 字段匹配)
+            const keys = Object.keys(query);
+            r = await store.query((doc) => keys.every((k) => doc?.[k] === query[k]));
+        }
+        else {
+            r = await store.get(String(query ?? ''));
+        }
+        return { ok: true, results: Array.isArray(r) ? r : (r ? [r] : []) };
+    }
+    catch (e) {
+        return { ok: false, error: String(e?.message || e) };
+    }
+}
+/** 关闭实例 (保留 helia 节点) */
+export async function stopMobileOrbitDB() {
+    try {
+        if (_orbit)
+            await _orbit.stop();
+        _orbit = null;
+        return { ok: true };
+    }
+    catch {
+        _orbit = null;
+        return { ok: true };
+    }
+}

package/dist/ios/mobile-persona.js

@@ -0,0 +1,80 @@
+// src/web/mobile-persona.ts
+var PERSONA_KEY = "bolloon_mobile_persona";
+var DEFAULT_PERSONA = {
+  name: "blln-mobile",
+  personality: "严谨、可靠、有边界感",
+  values: ["本地优先", "隐私优先", "诚实透明"],
+  interests: ["P2P 网络", "AI 智能体", "知识系统"],
+  style: "简洁中文，先给结论再给细节",
+  boundaries: ["不假装能做做不到的事", "不编造数据"],
+  extra: ""
+};
+function safeGet() {
+  try {
+    return window.localStorage;
+  } catch {
+    return globalThis.localStorage || { getItem: () => null, setItem: () => {
+    } };
+  }
+}
+function loadPersona() {
+  try {
+    const raw = safeGet().getItem(PERSONA_KEY);
+    if (!raw) return { ...DEFAULT_PERSONA };
+    const p = JSON.parse(raw);
+    return {
+      name: typeof p.name === "string" && p.name ? p.name : DEFAULT_PERSONA.name,
+      personality: typeof p.personality === "string" ? p.personality : DEFAULT_PERSONA.personality,
+      values: Array.isArray(p.values) ? p.values : DEFAULT_PERSONA.values,
+      interests: Array.isArray(p.interests) ? p.interests : DEFAULT_PERSONA.interests,
+      style: typeof p.style === "string" ? p.style : DEFAULT_PERSONA.style,
+      boundaries: Array.isArray(p.boundaries) ? p.boundaries : DEFAULT_PERSONA.boundaries,
+      extra: typeof p.extra === "string" ? p.extra : ""
+    };
+  } catch {
+    return { ...DEFAULT_PERSONA };
+  }
+}
+function savePersona(partial) {
+  const cur = loadPersona();
+  const next = {
+    name: typeof partial.name === "string" && partial.name.trim() ? partial.name.trim() : cur.name,
+    personality: typeof partial.personality === "string" ? partial.personality : cur.personality,
+    values: Array.isArray(partial.values) ? partial.values : cur.values,
+    interests: Array.isArray(partial.interests) ? partial.interests : cur.interests,
+    style: typeof partial.style === "string" ? partial.style : cur.style,
+    boundaries: Array.isArray(partial.boundaries) ? partial.boundaries : cur.boundaries,
+    extra: typeof partial.extra === "string" ? partial.extra : cur.extra
+  };
+  try {
+    safeGet().setItem(PERSONA_KEY, JSON.stringify(next));
+  } catch {
+  }
+  return next;
+}
+function resetPersona() {
+  try {
+    safeGet().removeItem(PERSONA_KEY);
+  } catch {
+  }
+  return { ...DEFAULT_PERSONA };
+}
+function buildPersonaPrompt(p = loadPersona()) {
+  const lines = [
+    `你的名字: ${p.name}`,
+    `性格: ${p.personality}`,
+    p.style ? `说话方式: ${p.style}` : "",
+    p.values.length ? `价值观: ${p.values.join("、")}` : "",
+    p.interests.length ? `兴趣: ${p.interests.join("、")}` : "",
+    p.boundaries.length ? `不做的事: ${p.boundaries.join("、")}` : "",
+    p.extra ? `补充: ${p.extra}` : ""
+  ].filter(Boolean);
+  return lines.join("\n");
+}
+export {
+  DEFAULT_PERSONA,
+  buildPersonaPrompt,
+  loadPersona,
+  resetPersona,
+  savePersona
+};

package/dist/ios/mobile-privacy.js

@@ -53,9 +53,8 @@ export const PRIVACY_SUMMARY = [
         body: '蓝牙扫描与连接：发现并连接附近设备与好友（已声明 neverForLocation，不用于推断位置）。' +
             '位置权限：仅 Android 11 及以下系统要求蓝牙扫描需要它（已限制 maxSdkVersion=30，Android 12+ 不再申请）。' +
             '网络：P2P 连接与下载。相机：调用系统相机应用完成拍摄，本应用不申请相机权限。' +
-            '完全访问权限（让智能体在这台手机上点按、滑动屏幕或调用系统能力）与 Shizuku：仅官网直装版本包含，默认开启' +
-            '（首次使用会直接带你去系统开关页确认一次，之后一直有效）、随时可以关闭；' +
-            '应用商店下载的版本不含这两项，也没有这个能力。',
+            '跨 App 点按、滑动屏幕或调用系统能力所需的 Android 无障碍与 Shizuku：仅官网直装版本包含，属于可选扩展能力；' +
+            '手机端基础 Agent 不依赖这些权限即可直接运行。应用商店下载的版本不含跨 App 控制能力。',
     },
     {
         title: '六、你的权利与注销',