@bolloon/bolloon-agent 0.5.0 → 0.5.1

package/dist/ios/routes-mobile-tasks.js

@@ -0,0 +1,353 @@
+/**
+ * routes-mobile-tasks.ts — 手机端「任务协作」的桌面 API (2026-09-25)
+ *
+ * 为什么需要这一层: 群的 store (OrbitDB) 与公告板 (落盘 + 注册表) 都在**桌面节点**上,
+ * 手机 WebView 跑不了它们。所以手机只做三件事 —— **输入 · 展示待发内容 · 设备签名**,
+ * 真正的执行一律回到桌面, 而且**调用与 CLI 完全相同的函数**
+ * (`gateway-group.ts` / `task-group.ts` / `task-board.ts`), 因此:
+ *   同一份存储 · 同一套协议 · 同一条隐私闸 —— 手机**不是**第二个权威源。
+ *
+ * 三条硬纪律 (与项目「手机=授权, 桌面=执行」的分工一致):
+ *   1. **高风险动作必须带设备签名** (`verdict` 由 `mobile-task-actions-verify.ts` 给出):
+ *      入群/退群/建群/发公告/公告入群/过程留痕 一律先验签, 且签名**绑定内容摘要** —— 换类型/换内容都验不过。
+ *   2. **读接口只回脱敏事实**: 群里只有短引用, 板上的 buyerDid 不出门 (手机按自己的一份视图投影再挡一道)。
+ *   3. **失败如实说**: 群不存在/没入群/桌面没身份/注册表不可达 → 结构化失败 + 人话原因, 不静默降级成"只写本地"。
+ */
+import { ContactChain } from '../agents/contacts/chain.js';
+import { verifyTaskAction } from '../agents/mobile-task-actions-verify.js';
+import { shortId } from '../agents/mobile-task-views.js';
+function fail(res, status, code, error, extra = {}) {
+    res.status(status).json({ ok: false, code, error, ...extra });
+}
+/** 把任意异常翻成人话 (不吞: 原文截断带上) */
+function reasonOf(e, max = 200) {
+    return String(e?.message || e || '未知原因').slice(0, max);
+}
+/** 「本机身份」——公告必须有可追责的买方; 没有身份就拒 (与 CLI publish 一致) */
+async function localSignerOrNull() {
+    try {
+        const { loadLocalSigner } = await import('../agents/local-signer.js');
+        const s = await loadLocalSigner();
+        return s ? { did: s.did, publicKeyHex: s.publicKeyHex, keypair: s.keypair } : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function registerMobileTaskRoutes(app, opts = {}) {
+    const now = () => (opts.now ? opts.now() : Date.now());
+    const chainFor = (ownerDid) => new ContactChain({
+        home: opts.home,
+        ownerDid: ownerDid || opts.ownerDid || 'did:bolln:local',
+        displayName: '本机用户',
+    });
+    /** 已登记设备公钥 (手机签名只认这些) —— 注入优先 (单测不起真实 store) */
+    async function deviceKeyOf(deviceId, ownerDid) {
+        if (opts.devices)
+            return opts.devices.find((d) => d.deviceId === deviceId) || null;
+        try {
+            const list = await chainFor(ownerDid).grants.listDevices();
+            return list.find((d) => d.deviceId === deviceId) || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * 高风险动作的统一入口: 形状 → 设备已登记 → 签名 → 时效 → 内容摘要。
+     * 任何一项不过都**不执行** (fail-closed)。
+     */
+    async function authorize(req, res, kind) {
+        const request = (req?.body?.request || {});
+        const signed = { action: req?.body?.action, signature: req?.body?.signature };
+        if (!request || String(request.kind || '') !== String(kind)) {
+            fail(res, 400, 'REQUEST_KIND_MISMATCH', `请求类型与路由不一致 (路由要求 ${kind}, 收到 ${String(request?.kind || '无')})`);
+            return { ok: false };
+        }
+        const deviceId = String(signed?.action?.deviceId || '');
+        const pub = deviceId ? await deviceKeyOf(deviceId, String(signed?.action?.ownerDid || '')) : null;
+        const v = verifyTaskAction(signed, pub, { req: request, now: now() });
+        if (!v.ok) {
+            fail(res, 403, 'SIGNATURE_REJECTED', `手机签名没通过: ${v.message || v.reason}`, { reason: v.reason, action: shortId(signed?.action?.actionId, 16) });
+            return { ok: false };
+        }
+        return { ok: true, req: request };
+    }
+    // ── ① 群 (与 CLI `bolloon task group …` 同一份 store) ─────────────────────
+    /** 本机已加入的群 (脱敏: 只给 groupId/群名/时间 —— 不放链接与 store 地址) */
+    app.get('/api/mobile/tasks/groups', async (_req, res) => {
+        try {
+            const { listGroups } = await import('../agents/gateway-group.js');
+            const groups = await listGroups();
+            res.json({
+                ok: true,
+                groups: groups.map((g) => ({ id: g.id, name: g.name, createdAt: g.createdAt })),
+                note: '只给群标识/群名/加入时间; 邀请链接要显式取 (与 CLI task group list 同一纪律)',
+            });
+        }
+        catch (e) {
+            fail(res, 500, 'GROUP_LIST_FAILED', `读群列表失败: ${reasonOf(e)}`);
+        }
+    });
+    /** 群列表 (给手机确认页做 ref 校验用; 不放链接) */
+    app.get('/api/mobile/tasks/groups/resolve', async (req, res) => {
+        try {
+            const { resolveGroupRef } = await import('../agents/task-group.js');
+            const r = await resolveGroupRef(String(req.query?.group || ''));
+            if (!r.ok)
+                return fail(res, 404, r.code, r.message, { detail: r.detail });
+            res.json({ ok: true, group: { id: r.group.groupId, name: r.group.name, via: r.group.via } });
+        }
+        catch (e) {
+            fail(res, 500, 'GROUP_RESOLVE_FAILED', `解析群失败: ${reasonOf(e)}`);
+        }
+    });
+    // ── ② 公告: 看板 (只读, 与 CLI `task board` 同一份事实) ─────────────────
+    app.get('/api/mobile/tasks/board', async (req, res) => {
+        try {
+            const { listBoard } = await import('../agents/task-board.js');
+            const localOnly = String(req.query?.local || '') === '1';
+            const openOnly = String(req.query?.open || '') === '1';
+            const view = await listBoard({ home: opts.home, now: now(), localOnly, openOnly });
+            // 只回手机要用的字段: buyerDid / claimedBy 是身份, **不出门** (手机侧再投影一次)
+            res.json({
+                ok: true,
+                entries: view.entries.map((e) => ({
+                    announcementId: e.announcementId, capability: e.capability, status: e.status,
+                    budget: e.budget, deadline: e.deadline, createdAt: e.createdAt, claimCount: e.claimCount,
+                    instructionDigest: e.instructionDigest, instructionPreview: e.instructionPreview,
+                    remote: e.remote, source: e.source, signatureVerified: e.signatureVerified, claimable: e.claimable,
+                })),
+                localCount: view.localCount, remoteCount: view.remoteCount, registryReady: view.registryReady,
+                registryError: view.registryError, notes: view.notes,
+            });
+        }
+        catch (e) {
+            fail(res, 500, 'BOARD_FAILED', `读看板失败: ${reasonOf(e)}`);
+        }
+    });
+    /** 群里的一期过程痕迹 (只读, 与 CLI `task trail --group …` 同一份汇总) */
+    app.get('/api/mobile/tasks/trail', async (req, res) => {
+        try {
+            const { resolveGroupRef, readTrail } = await import('../agents/task-group.js');
+            const ref = await resolveGroupRef(String(req.query?.group || ''));
+            if (!ref.ok)
+                return fail(res, 404, ref.code, ref.message, { detail: ref.detail });
+            const limit = Number(req.query?.limit) || 300;
+            const announcementId = req.query?.announcementId ? String(req.query.announcementId) : null;
+            const summary = await readTrail(ref.group.groupId, { limit, announcementId });
+            res.json({ ok: true, group: { id: ref.group.groupId, name: ref.group.name }, summary });
+        }
+        catch (e) {
+            fail(res, 500, 'TRAIL_FAILED', `读群痕迹失败: ${reasonOf(e)}`);
+        }
+    });
+    /** 预览: 用**将要发送的同一个构造器**生成那一行 (只展示, 不发送, 不需要签名) */
+    app.post('/api/mobile/tasks/preview', async (req, res) => {
+        try {
+            const request = (req?.body?.request || {});
+            const built = await buildGroupText(request, opts.home);
+            if (!built.ok)
+                return fail(res, 400, built.code, built.error);
+            res.json({ ok: true, text: built.text, note: '预览由桌面的构造器生成: 与你确认后真正发进群的那一行同源' });
+        }
+        catch (e) {
+            fail(res, 500, 'PREVIEW_FAILED', `生成预览失败: ${reasonOf(e)}`);
+        }
+    });
+    // ── 执行 (验签 → 调用与 CLI 相同的函数) ───────────────────────────────────
+    app.post('/api/mobile/tasks/execute', async (req, res) => {
+        try {
+            const kind = String(req?.body?.request?.kind || '');
+            const auth = await authorize(req, res, kind);
+            if (!auth.ok)
+                return;
+            const request = auth.req;
+            const ownerDid = String((req?.body?.action?.ownerDid || '') || '');
+            if (kind === 'group_create' || kind === 'group_join' || kind === 'group_leave') {
+                const { createGroup, joinGroup, leaveGroup } = await import('../agents/gateway-group.js');
+                if (kind === 'group_create') {
+                    const r = await createGroup(String(request.groupRef || '').trim());
+                    if (!r.ok || !r.group)
+                        return fail(res, 409, 'GROUP_CREATE_FAILED', `建群失败: ${r.error || '未知原因'}`);
+                    return res.json({ ok: true, kind, group: { id: r.group.id, name: r.group.name }, text: `已建群「${r.group.name}」` });
+                }
+                if (kind === 'group_join') {
+                    const { parseGroupLink } = await import('../agents/gateway-group.js');
+                    const raw = String(request.groupRef || '').trim();
+                    if (!/^orbitdb:\/\//i.test(raw))
+                        return fail(res, 400, 'INVALID_GROUP_LINK', '入群需要群邀请链接 (orbitdb://…?type=group&name=…)');
+                    if (!parseGroupLink(raw))
+                        return fail(res, 400, 'INVALID_GROUP_LINK', '邀请链接解析失败 → 拒 (不猜你要进哪个群)');
+                    const r = await joinGroup(raw);
+                    if (!r.ok || !r.group)
+                        return fail(res, 409, 'GROUP_JOIN_FAILED', `入群失败: ${r.error || '未知原因'}`);
+                    return res.json({ ok: true, kind, group: { id: r.group.id, name: r.group.name }, already: !!r.already, text: r.already ? `本来就在「${r.group.name}」` : `已入群「${r.group.name}」` });
+                }
+                const r = await leaveGroup(String(request.groupRef || '').trim());
+                if (!r.ok)
+                    return fail(res, 409, 'GROUP_LEAVE_FAILED', `退群失败: ${r.error || '未知原因'}`);
+                return res.json({ ok: true, kind, text: `已退群 (只摘本机记录)`, removed: r.removed });
+            }
+            if (kind === 'announce_publish') {
+                const signer = await localSignerOrNull();
+                if (!signer)
+                    return fail(res, 400, 'NO_LOCAL_IDENTITY', '本机没有可签名的身份 (~/.bolloon/identity.json) → 公告没有可追责的买方, 拒发');
+                const { toAtomic, parseDeadline } = await import('../cli/commands/tasks.js');
+                const currency = String(request.currency || 'USDC').toUpperCase();
+                if (currency !== 'USDC' && currency !== 'ETH')
+                    return fail(res, 400, 'INVALID_CURRENCY', `币种只支持 USDC/ETH (收到 ${currency})`);
+                const atomic = toAtomic(String(request.budgetHuman || ''), currency === 'USDC' ? 6 : 18);
+                if (!atomic)
+                    return fail(res, 400, 'INVALID_BUDGET', '预算必须是正数 (原子单位由桌面换算, 不接受 0/负/超精度)');
+                const dl = parseDeadline(request.deadline === null || request.deadline === undefined || request.deadline === '' ? undefined : String(request.deadline), now());
+                if (typeof dl === 'string')
+                    return fail(res, 400, 'INVALID_DEADLINE', dl);
+                const { publishAnnouncement } = await import('../agents/task-board.js');
+                const r = await publishAnnouncement({
+                    capability: String(request.capability || ''),
+                    instruction: String(request.instruction || ''),
+                    buyerDid: signer.did,
+                    buyerPublicKeyHex: signer.publicKeyHex,
+                    budget: { maxAmount: atomic, currency, network: 'base-sepolia' },
+                    deadline: dl,
+                    paymentMode: 'policy',
+                    signerKeypair: signer.keypair,
+                }, { home: opts.home, now: now() });
+                if (!r.ok || !r.announcement)
+                    return fail(res, 500, 'ANNOUNCE_PUBLISH_FAILED', `公告没发布成功: ${r.error || '未知原因'}`);
+                return res.json({
+                    ok: true, kind, announcementId: r.announcement.announcementId, dup: !!r.dup,
+                    registryAnnounced: r.registry?.announced === true, registryError: r.registry?.error || null,
+                    text: r.dup ? '这条公告本来就在板上 (幂等, 没有重复发)' : '公告已发布 (落盘 + 尽力向注册表公告)',
+                });
+            }
+            // announce_to_group / trail_post: 生成那一行 → 隐私闸 → 发进群
+            const built = await buildGroupText(request, opts.home);
+            if (!built.ok)
+                return fail(res, 400, built.code, built.error);
+            const { sendTrailMessage, resolveSenderTag } = await import('../agents/task-group.js');
+            const tag = await resolveSenderTag(null);
+            if (!tag.ok)
+                return fail(res, 400, tag.code, tag.message);
+            const sent = await sendTrailMessage(built.groupId, built.text, tag.tag);
+            if (!sent.sent) {
+                return fail(res, 409, 'GROUP_SEND_REFUSED', sent.error || '群消息没发出去', { violations: sent.violations || [] });
+            }
+            return res.json({ ok: true, kind, text: sent.text, senderTag: tag.tag });
+        }
+        catch (e) {
+            fail(res, 500, 'EXECUTE_FAILED', `执行失败: ${reasonOf(e)}`);
+        }
+    });
+    // ── ③ 飞轮进度 (只读消费 goal-flywheel 冻结类型; 投影在桌面做, 手机只渲染) ──
+    app.get('/api/mobile/tasks/flywheel', async (_req, res) => {
+        try {
+            const { listGoals } = await import('../agents/goal-store.js');
+            const { buildMobileFlywheelView, findInternalFieldLeaks } = await import('../agents/mobile-flywheel-view.js');
+            const { GOAL_TERMINAL_STATES } = await import('../agents/goal-flywheel/types.js');
+            const goals = await listGoals({ limit: 20 });
+            const t = now();
+            let decisionReadFailures = 0;
+            const items = [];
+            for (const g of goals) {
+                const status = String(g?.status || '');
+                // 终态判据来自冻结面 (不在这里重列一遍 completed/failed/abandoned)
+                const terminal = GOAL_TERMINAL_STATES.includes(status);
+                // 只读消费: goal-store 的 continuation 可整体读作 goal-flywheel 的 GoalContinuationRecord (冻结面)。
+                // 终态目标在 store 里没有 continuation (冻结语义), 但 toUserVisibleState 判"已结束"要读 state ——
+                // 所以把 **store 里的真实 status** 装进它要的形状, 不新增任何状态、不编造下一步。
+                const continuation = (g?.continuation && typeof g.continuation === 'object')
+                    ? {
+                        nextAction: String(g.continuation.nextAction || ''),
+                        wakeAt: g.continuation.wakeAt || null,
+                        wakeReason: String(g.continuation.wakeReason || ''),
+                        autoContinue: g.continuation.autoContinue === true,
+                        requiredAgent: g.continuation.requiredAgent || null,
+                        pendingReports: [],
+                        unresolvedItems: Array.isArray(g.unresolvedItems) ? g.unresolvedItems.map((x) => String(x)) : [],
+                        lastDecisionId: g.continuation.lastDecisionId || null,
+                        state: status || 'active',
+                        updatedAt: String(g.continuation.updatedAt || g.updatedAt || new Date(t).toISOString()),
+                    }
+                    : (terminal
+                        ? {
+                            nextAction: '', wakeAt: null, wakeReason: '', autoContinue: false, requiredAgent: null,
+                            pendingReports: [], unresolvedItems: [], lastDecisionId: null,
+                            state: status, updatedAt: String(g?.updatedAt || new Date(t).toISOString()),
+                        }
+                        : null);
+                // 决策记录: 用飞轮接线自己的读函数 (只读; 没有/还没接线 → null, 不编造)
+                let decision = null;
+                try {
+                    const w = await import('../agents/goal-flywheel-wiring.js');
+                    if (typeof w?.readDecisionRecords === 'function') {
+                        const recs = await w.readDecisionRecords(String(g?.goalId || g?.id || ''), opts.home);
+                        const last = Array.isArray(recs) && recs.length ? recs[recs.length - 1] : null;
+                        decision = last?.decision ?? null;
+                    }
+                }
+                catch {
+                    decisionReadFailures++;
+                    decision = null;
+                }
+                // 阻塞清单: 今天的飞轮没有可供手机读的阻塞存储 (monitor 状态归飞轮接线) → 如实空表, 不假装
+                const view = buildMobileFlywheelView({ continuation, blocks: [], decision, now: t });
+                items.push({
+                    objectiveShort: String(g?.objective || '').slice(0, 40),
+                    status,
+                    terminal,
+                    view,
+                });
+            }
+            // 自检: 投影里出现内部字段名 → 宁可不给数据 (findInternalFieldLeaks 来自冻结面)
+            const leaks = findInternalFieldLeaks(JSON.stringify(items));
+            if (leaks.length)
+                return fail(res, 500, 'VIEW_LEAK', `飞轮投影里混进了内部字段: ${leaks.join(', ')} → 拒发`);
+            res.json({
+                ok: true, goals: items,
+                hint: items.length ? null : '还没有 Goal 记录: 在桌面/CLI 立一个长期目标后, 这里会显示它在第几类状态 (只读)',
+                note: decisionReadFailures
+                    ? '本页只读消费 goal-flywheel 的五类用户可见状态; 有目标的决策记录这次没读到 (不影响状态判定)'
+                    : '本页只读消费 goal-flywheel 的五类用户可见状态 (toUserVisibleState); 阻塞清单要等飞轮接线把 detectBlocks 的产物落盘后才有数据',
+            });
+        }
+        catch (e) {
+            fail(res, 500, 'FLYWHEEL_FAILED', `读飞轮进度失败: ${reasonOf(e)}`);
+        }
+    });
+}
+async function buildGroupText(request, home) {
+    const TG = await import('../agents/task-group.js');
+    const ref = await TG.resolveGroupRef(String(request.groupRef || ''));
+    if (!ref.ok)
+        return { ok: false, code: ref.code, error: ref.message };
+    if (request.kind === 'announce_to_group') {
+        const a = TG.pickAnnouncement({
+            home,
+            announcementId: request.announcementId,
+            capability: null,
+        });
+        if (!a.ok)
+            return { ok: false, code: a.code, error: a.message };
+        return { ok: true, groupId: ref.group.groupId, text: TG.buildAnnounceMessage(a.announcement, { round: request.round, criteria: request.criteria }) };
+    }
+    if (request.kind === 'trail_post') {
+        const kind = String(request.trailKind || '');
+        const built = TG.buildPostMessage({
+            kind,
+            announcementId: request.announcementId,
+            round: request.round,
+            price: request.price,
+            hash: request.hash,
+            bytes: request.bytes,
+            checksRaw: request.checks,
+            verdict: request.verdict,
+        });
+        if (!built.ok)
+            return { ok: false, code: built.code, error: built.message };
+        return { ok: true, groupId: ref.group.groupId, text: built.text };
+    }
+    return { ok: false, code: 'INVALID_ARGUMENT', error: `这一类动作没有群消息文本: ${String(request.kind)}` };
+}
+export default { registerMobileTaskRoutes };

package/dist/ios/server.js

@@ -15,6 +15,8 @@ import { registerExternalEngineRoutes } from './routes-external-engines.js';
 import { registerTaskRoutes } from './routes-tasks.js';
 // 2026-09-19: 联系方式 / 人工批准 / 手机—桌面配对 路由
 import { registerContactRoutes } from './routes-contacts.js';
+// 2026-09-25: 手机端「任务协作」(入群 / 发公告 / 看飞轮进度) 路由 —— 高风险动作由设备签名把关
+import { registerMobileTaskRoutes } from './routes-mobile-tasks.js';
 // 2026-09-13: 微支付信息服务 (x402) 路由
 import { registerX402InfoRoutes } from './routes-x402-info.js';
 // 2026-09-22: P5 链上索引 (只读: status/stats/timeline/events 增量) 路由
@@ -3108,6 +3110,12 @@ async function act(id, what){
   else if (what === 'abort') { const r = await fetch('/api/runs/'+id+'/abort',{method:'POST'}); log(await r.json()); }
   refresh();
 }
+async function req(id){
+  const text = prompt('新要求 (原话逐字入档; 只影响后续 Run, 不改写已发生的历史。若说"撤销/别继续做了", 在跑的这一轮会在下一次循环停下):');
+  if (!text) return;
+  const r = await fetch('/api/goals/'+id+'/requirement',{method:'POST',headers:{'content-type':'application/json'},body:JSON.stringify({text})});
+  log(await r.json()); refresh();
+}
 async function refresh(){
   try {
     const sup = await j('/api/supervisor');
@@ -3115,14 +3123,20 @@ async function refresh(){
       ' <span class="dim">lease='+(sup.leaseTtlMs||'-')+'ms tick='+(sup.tickIntervalMs||'-')+'ms</span>';
   } catch(e){ document.getElementById('sup').textContent = 'supervisor 不可用: '+e; }
   const gs = await j('/api/goals');
+  const labels = gs.visibleLabels || {};
+  const visMap = {}; (gs.goals || []).forEach((g, i) => { visMap[g.goalId] = (gs.visible || [])[i]; });
   const gtb = document.querySelector('#goals tbody'); gtb.innerHTML = '';
   for (const g of (gs.goals || [])) {
     let crit = g.successCriteria?.length ? (g.completedCriteria?.length||0)+'/'+g.successCriteria.length : '<span class="bad">无判据</span>';
     const src = g.criteriaSource ? ' <span class="dim">('+g.criteriaSource+(g.criteriaConfirmed?'✓':'?')+')</span>' : '';
     const tr = document.createElement('tr');
-    tr.innerHTML = '<td><code>'+g.goalId+'</code></td><td>'+g.status+'</td><td>'+crit+src+'</td><td class="dim">'+
+    const vis = (visMap[g.goalId]) || (g.continuation ? 'executing' : 'executing');
+    const visZh = (labels[vis] && labels[vis].zh) || vis;
+    const pend = (gs.pendingChanges||[])[(gs.goals||[]).indexOf(g)];
+    const pendZh = pend ? ' <span class="bad">('+pend+' 条变更等你决定)</span>' : '';
+    tr.innerHTML = '<td><code>'+g.goalId+'</code></td><td>'+visZh+pendZh+' <span class="dim">('+vis+')</span></td><td>'+crit+src+'</td><td class="dim">'+
       ((g.continuation&&(g.continuation.nextAction||g.continuation.wakeReason))||'-')+'</td><td>'+((g.runs||[]).length)+'</td>'+
-      '<td><button onclick="view(\''+g.goalId+'\')">详情</button><button onclick="act(\''+g.goalId+'\',\'confirm\')">确认判据</button><button onclick="act(\''+g.goalId+'\',\'propose\')">提候选</button><button onclick="act(\''+g.goalId+'\',\'wake\')">唤醒</button></td>';
+      '<td><button onclick="view(\\''+g.goalId+'\\')">详情</button><button onclick="act(\\''+g.goalId+'\\',\\'confirm\\')">确认判据</button><button onclick="act(\\''+g.goalId+'\\',\\'propose\\')">提候选</button><button onclick="act(\\''+g.goalId+'\\',\\'wake\\')">唤醒</button><button onclick="req(\\''+g.goalId+'\\')">新要求</button></td>';
     gtb.appendChild(tr);
   }
   const rs = await j('/api/runs');
@@ -3130,7 +3144,7 @@ async function refresh(){
   for (const r of (rs.runs || []).slice(-20).reverse()) {
     const tr = document.createElement('tr');
     tr.innerHTML = '<td><code>'+String(r.runId).slice(0,14)+'</code></td><td class="dim">'+(r.goalId||'-')+'</td><td>'+r.status+'</td><td>'+((r.steps||[]).length)+'</td><td>'+((r.recovery||[]).length)+'</td>'+
-      '<td><button onclick="act(\''+r.runId+'\',\'resume\')">resume</button><button onclick="act(\''+r.runId+'\',\'pause\')">pause</button><button onclick="act(\''+r.runId+'\',\'abort\')">abort</button></td>';
+      '<td><button onclick="act(\\''+r.runId+'\\',\\'resume\\')">resume</button><button onclick="act(\\''+r.runId+'\\',\\'pause\\')">pause</button><button onclick="act(\\''+r.runId+'\\',\\'abort\\')">abort</button></td>';
     rtb.appendChild(tr);
   }
 }
@@ -3339,6 +3353,7 @@ fetchState();
             const { getSupervisor } = await import('../agents/execution-supervisor.js');
             const { readSupervisorState, supervisorStatePath } = await import('../agents/supervisor-host.js');
             const { wakeReport, listRunnableGoals } = await import('../agents/goal-store.js');
+            const { goalVisibleState } = await import('../agents/goal-flywheel-wiring.js');
             const { runnable, skipped } = await listRunnableGoals({ now: Date.now() });
             res.json({
                 supervisor: getSupervisor().status(),
@@ -3346,6 +3361,15 @@ fetchState();
                 host: await readSupervisorState(),
                 hostStatePath: supervisorStatePath(),
                 wake: await wakeReport(),
+                // 2026-09-25 (飞轮接线 §7): 用户可见态 (六类) —— 界面不得自己造第二套映射
+                wakeVisible: await Promise.all((await wakeReport()).map(async (r) => {
+                    try {
+                        return { goalId: r.goalId, visible: await goalVisibleState({ goalId: r.goalId }) };
+                    }
+                    catch {
+                        return { goalId: r.goalId, visible: r.visible };
+                    }
+                })),
                 runnable: runnable.map((g) => ({ goalId: g.goalId, objective: g.objective, status: g.status })),
                 skipped,
             });
@@ -3395,6 +3419,111 @@ fetchState();
             res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
         }
     });
+    // 2026-09-25 (飞轮接线 P4 / M4 深化): 新要求注入 —— 原话逐字入档 + 分诊 + 版本; 只影响**后续** Run。
+    //   当前 Run 不被历史改写 (规则 4): 本路由只写 Goal 上的变更记录与下一 Run 的指令。
+    //   ★ M4: 这里还要回答"**正在跑的 Goal** 会发生什么" —— 撤销 → 在跑的这一轮必须停
+    //     (走既有外部控制面原语 `setRunStatus`, 与 /api/runs/:id/abort 同一条路; 执行器只在需要时才注入,
+    //      判定本身在 change 接缝里, 本路由不自己判)。事实 (在跑的 Run / 在跑的子 Agent) 由本路由读出来喂进去。
+    app.post('/api/goals/:goalId/requirement', async (req, res) => {
+        const goalId = String(req.params.goalId);
+        try {
+            const { readGoal } = await import('../agents/goal-store.js');
+            const { readRun } = await import('../agents/run-store.js');
+            const { flywheelSeams } = await import('../agents/goal-flywheel-wiring.js');
+            const { isRefusal } = await import('../agents/goal-flywheel/wiring/index.js');
+            const { USER_VISIBLE_STATE_LABELS } = await import('../agents/goal-flywheel/types.js');
+            const text = String(req.body?.text ?? '').trim();
+            if (!text) {
+                res.status(400).json({ error: '缺少 text (新要求的原话)' });
+                return;
+            }
+            const goal = await readGoal(goalId);
+            if (!goal) {
+                res.status(404).json({ error: `goal 不存在: ${goalId}` });
+                return;
+            }
+            // 在跑的 Run 的事实 (读不到记录 = 没有可停的对象; 绝不因为"读不到"去停一个不存在的 Run)
+            const runRec = goal.currentRunId ? await readRun(goal.currentRunId).catch(() => null) : null;
+            // 在跑的子 Agent = 已签合同还没回报的那些 (规则 5: 它们必须先收到变更版本)
+            const liveWorkIds = (goal.continuation?.pendingReports ?? []).map((p) => p.workId).filter(Boolean);
+            const now = new Date().toISOString();
+            const seam = flywheelSeams().change;
+            const view = await seam.ingestChange({
+                goalId,
+                instruction: text,
+                source: 'user',
+                recordedBy: 'web',
+                now,
+                runningRun: runRec ? { runId: runRec.runId, status: String(runRec.status) } : null,
+                liveWorkIds,
+                caller: 'human',
+            });
+            if (isRefusal(view)) {
+                res.status(409).json({ ok: false, refused: true, rule: view.rule, reason: view.reason, goalId });
+                return;
+            }
+            // 计划说要停, 而接缝自己没执行器 (M0 尚未注入 stopRunningRun) → 入口按计划把停落到真 Run 上:
+            //   执行器 = 既有的 setRunStatus (与 /api/runs/:id/abort 同一个原语, 不新造停止通道)。
+            let boundary = view.runBoundary;
+            if (boundary.action === 'stop_running_run' && !boundary.stopped) {
+                const { setRunStatus } = await import('../agents/run-store.js');
+                boundary = await seam.applyRunBoundary({
+                    plan: view.plan,
+                    now,
+                    stop: async (i) => {
+                        const r = await setRunStatus(i.runId, i.runStatus, { error: `变更注入 (${i.goalId}): ${String(i.reason).slice(0, 120)}` });
+                        return { ok: !!r.ok, reason: r.reason || '' };
+                    },
+                });
+            }
+            const bumped = view.plan.outcome === 'next_run' && view.request.kind === 'success_criteria_change'
+                ? view.plan.criteriaVersion
+                : null;
+            res.json({
+                ok: true,
+                goalId,
+                changeId: view.request.changeId,
+                kind: view.request.kind,
+                outcome: view.plan.outcome,
+                status: view.request.status,
+                /** 只有"用户 + 改判据"才 +1 (规则 3); 其余一律 null */
+                criteriaVersionBumpedTo: bumped,
+                criteriaVersion: view.plan.criteriaVersion,
+                /** 下一 Run 真的会读到的指令 (写进 continuation.nextAction) */
+                nextRunDirective: view.plan.nextRunDirective,
+                /** ★ 正在运行的 Goal: 在跑的这一轮停不停 (停不了也会如实说) */
+                runBoundary: boundary,
+                appliesToFutureRunsOnly: view.plan.appliesToFutureRunsOnly,
+                /** 规则 5: 在跑的子 Agent 各拿一份下发内容, 且必须先 ack */
+                childDelivery: {
+                    count: view.childDelivery.directives.length,
+                    workIds: view.childDelivery.workIds,
+                    mustAck: view.childDelivery.mustAck,
+                    scopeMissing: view.childDelivery.scopeMissing,
+                    blocked: view.childDelivery.blocked,
+                    note: view.childDelivery.note,
+                },
+                /** 用户可见态 (六类之一): 有待拍板的变更 → "需要你决定"; null = 基础态读不到 (不编) */
+                visibleState: view.visibleState,
+                visibleZh: view.visibleState ? (USER_VISIBLE_STATE_LABELS[view.visibleState]?.zh || view.visibleState) : null,
+                visibleReason: view.visibleReason,
+                /** 一个 kind 装不下多个意图 → 已入档但不生效, 需拆开重提 */
+                needsDisambiguation: view.needsDisambiguation,
+                /** 流程留痕 (接收→记录→判影响→摘要→评估当前Run→必要时停→重规划→写入下一Run) */
+                steps: view.plan.steps,
+                changeArchive: {
+                    authoritative: 'goal.goalChanges (Goal 记录 = 权威; 界面/下一次 Run 读它)',
+                    mirror: '~/.bolloon/goal-changes/<goalId>.json (镜像, 由接线层写)',
+                },
+                note: view.plan.outcome === 'rejected'
+                    ? '未生效 (见 outcome): 已如实入档, 不会偷偷生效'
+                    : '已生效: 只影响后续 Run, 已发生的 Run 记录不被改写',
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
+        }
+    });
     // 2026-09-16 (M5): 运行列表 —— Web 与 CLI 读同一份 run 事实 (~/.bolloon/runs)
     app.get('/api/runs', async (req, res) => {
         try {
@@ -3519,7 +3648,34 @@ fetchState();
             const { listGoals, formatGoalLine } = await import('../agents/goal-store.js');
             const status = String(req.query?.status || '').trim();
             const goals = await listGoals({ status: status ? status : undefined, limit: Number(req.query?.limit || 30) });
-            res.json({ count: goals.length, goals, lines: goals.map(formatGoalLine) });
+            // 2026-09-25 (飞轮接线): 界面只认 `toUserVisibleState` 映射的**六类**用户可见态 ——
+            //   内部状态 (retry_wait / stalled / recovering) 不再直接上屏。
+            // ★ M4: 再过一遍**变更驱动**的覆盖 —— 有待拍板的新要求 (`needs_approval`) 时必须是
+            //   "需要你决定", 否则界面一直显示"正在执行", 没人知道有东西卡在等人 (只升不降)。
+            const { toUserVisibleState } = await import('../agents/goal-flywheel/work-monitor.js');
+            const { changeVisibleState } = await import('../agents/goal-flywheel/wiring/change.js');
+            const { collectWorkBlocks } = await import('../agents/goal-flywheel-wiring.js');
+            const { USER_VISIBLE_STATE_LABELS } = await import('../agents/goal-flywheel/types.js');
+            const visible = await Promise.all(goals.map(async (g) => {
+                try {
+                    const base = toUserVisibleState(g.continuation ? { ...g.continuation } : null, await collectWorkBlocks({ goalId: g.goalId }), null, 
+                    // ★ M5-⑥ (2026-09-25): 界面认 Goal **本体**的终态 —— 完不成这一步的话, 一份落后的
+                    //   continuation 就能把"已完成"的目标显示成"正在执行" (界面比系统更乐观)。
+                    String(g.status ?? '') || null);
+                    // 这里 base 一定读得到 (读不到就是上面的 catch) → 覆盖结果为 null 时回落 base 本身
+                    // (不是编一个态: base 是这一步刚刚读出来的真态)
+                    return changeVisibleState({ base, changes: g.goalChanges ?? [] }).state ?? base;
+                }
+                catch {
+                    return 'executing';
+                }
+            }));
+            res.json({
+                count: goals.length, goals, lines: goals.map(formatGoalLine),
+                visible, visibleZh: visible.map((v) => USER_VISIBLE_STATE_LABELS[v]?.zh || v), visibleLabels: USER_VISIBLE_STATE_LABELS,
+                /** 待拍板的变更 (界面/CLI 用同一份事实说清"你在等什么") */
+                pendingChanges: goals.map((g) => (g.goalChanges ?? []).filter((c) => c.status === 'needs_approval' || c.status === 'triaged').length),
+            });
         }
         catch (err) {
             res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
@@ -6814,6 +6970,9 @@ fetchState();
     // 2026-09-19: 社交身份 API (DID + 已验证联系方式 + 联系能力 + 权限 + 证据)
     //   只返回脱敏值; 明文联系方式不进 Run/prompt/Git
     registerContactRoutes(app, {});
+    // 2026-09-25: 手机端「任务协作」API (入群 / 发公告 / 看飞轮进度)
+    //   手机只做 输入·展示待发内容·设备签名; 执行回到桌面, 调用与 CLI 同一批函数 (同一份 store 与协议)
+    registerMobileTaskRoutes(app, {});
     // 2026-09-13: 微支付信息服务 (x402) — 发布 / 402 收款 / 买方代付 / 验真
     registerX402InfoRoutes(app);
     registerOnchainTradeRoutes(app);

package/dist/ios/sw.js

@@ -6,7 +6,7 @@
  * 现在: 代码类资源 (html/js/css/json) 一律 **network-first** (拿不到网才回退缓存),
  *   缓存名带版本号, activate 时清掉所有旧缓存; 图标等静态资源仍 cache-first。
  */
-const CACHE = 'bolloon-mobile-v1.1';
+const CACHE = 'bolloon-mobile-v0.5.1';
 const SHELL = [
   './mobile.html',
   './mobile.css',