@bolloon/bolloon-agent 0.6.2 → 0.6.4

package/dist/agents/opportunity-match.js

@@ -0,0 +1,260 @@
+/**
+ * opportunity-match.ts — 意图 ↔ 机会 匹配引擎 (2026-10-05, leo Intent Network P0)
+ *
+ * ★ 设计原则 (leo 2026-10-05 三次纠偏): **自动校准, 不是「输入→扫描→结果」**。
+ *   · 默认就是匹配状态: 没有 intent 也流入**世界变化流** (最近的 open 公告, 按新鲜度),
+ *     不是「等待意图声明」的空态 —— 打开即有内容。
+ *   · 匹配随交互越来越准: ignore/accept 写 `world/memory/feedback.json` (负/正证据),
+ *     已忽略的同源公告不再流入; 是持续的校准环, 不依赖任何按钮。
+ *   · 机会源 v1: task board (listBoard, 本地 + 注册表)。后续: 群 announce / x402 商品。
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { listIntents, worldDir } from './intent-store.js';
+import { listBoard } from './task-board.js';
+import { readProfile } from './world-profile.js';
+function tagsOf(text) {
+    const src = String(text || '').toLowerCase();
+    const words = src.match(/[a-z][a-z0-9_-]{1,}/g) || [];
+    const cjk = src.match(/[\u4e00-\u9fff]{2,}/g) || [];
+    return Array.from(new Set([...words, ...cjk]));
+}
+function tagOverlap(a, b) {
+    if (!a.length || !b.length)
+        return 0;
+    const setB = new Set(b);
+    const hit = a.filter((t) => setB.has(t));
+    return hit.length / Math.max(a.length, 1);
+}
+function keywordHit(intentText, oppText) {
+    const words = tagsOf(intentText).filter((t) => t.length >= 3);
+    if (!words.length)
+        return 0;
+    const lower = String(oppText || '').toLowerCase();
+    const hit = words.filter((w) => lower.includes(w));
+    return hit.length / Math.max(words.length, 1);
+}
+function budgetFit(intentBudget, oppBudget) {
+    if (intentBudget === null || oppBudget === null)
+        return 0.5; // 缺失 = 中性
+    const i = Number(intentBudget) || 0;
+    const o = Number(oppBudget.maxAmount) || 0;
+    if (i <= 0 || o <= 0)
+        return 0.5;
+    if (o <= i)
+        return 1;
+    return Math.max(0, 1 - (o - i) / i);
+}
+const feedback = () => path.join(worldDir(), 'memory', 'feedback.json');
+// ── 世界观察日志 (2026-10-05, leo: 机会进入 AI 视野是主动性行为) ──────────────
+// 每次扫描 = AI 睁眼观察世界; 看到高分机会就记一条观察 (world/memory/events.jsonl)。
+// 这是「AI 自动观察」的落点: 不是人看了记, 是扫描这个动作自己留下视野记录。
+const eventsFile = () => path.join(worldDir(), 'memory', 'events.jsonl');
+/** 追加一条观察 (尽力而为, 失败不阻断扫描) */
+export async function noteObservation(obs) {
+    try {
+        await fs.mkdir(path.dirname(eventsFile()), { recursive: true });
+        await fs.appendFile(eventsFile(), JSON.stringify(obs) + '\n', { mode: 0o600 });
+    }
+    catch { /* 观察记录失败不阻断 */ }
+}
+/** 读观察日志 (最近 N 条, 倒序) */
+export async function readObservations(limit = 50) {
+    try {
+        const raw = await fs.readFile(eventsFile(), 'utf-8');
+        const lines = raw.split('\n').filter(Boolean).slice(-limit * 2);
+        const out = [];
+        for (const l of lines) {
+            try {
+                const p = JSON.parse(l);
+                if (p && typeof p === 'object' && typeof p.sourceId === 'string')
+                    out.push(p);
+            }
+            catch { /* 坏行跳过 */ }
+        }
+        return out.slice(-limit).reverse();
+    }
+    catch {
+        return [];
+    }
+}
+async function readFeedback() {
+    try {
+        const raw = await fs.readFile(feedback(), 'utf-8');
+        const parsed = JSON.parse(raw);
+        return { version: 1, ignored: Array.isArray(parsed.ignored) ? parsed.ignored : [], accepted: Array.isArray(parsed.accepted) ? parsed.accepted : [] };
+    }
+    catch {
+        return { version: 1, ignored: [], accepted: [] };
+    }
+}
+async function writeFeedback(fb) {
+    try {
+        await fs.mkdir(path.dirname(feedback()), { recursive: true });
+        await fs.writeFile(feedback(), JSON.stringify(fb, null, 2) + '\n', { mode: 0o600 });
+    }
+    catch { /* 反馈写失败不阻断 (尽力而为) */ }
+}
+/** 记录交互反馈 (校准环): ignore → 负证据 (同源不再流入), accept → 正证据 */
+export async function recordFeedback(action, sourceId) {
+    const sid = String(sourceId || '').trim();
+    if (!sid)
+        return { ok: false, error: '缺 sourceId' };
+    const fb = await readFeedback();
+    if (action === 'ignore') {
+        if (!fb.ignored.includes(sid))
+            fb.ignored.push(sid);
+        fb.accepted = fb.accepted.filter((s) => s !== sid);
+    }
+    else {
+        if (!fb.accepted.includes(sid))
+            fb.accepted.push(sid);
+        fb.ignored = fb.ignored.filter((s) => s !== sid);
+    }
+    await writeFeedback(fb);
+    return { ok: true };
+}
+function candidateOf(entry, intentId, score, reason, matchTags) {
+    return {
+        id: `opp_${entry.announcementId.slice(0, 12)}`,
+        intentId,
+        source: entry.source || 'board',
+        sourceId: entry.announcementId,
+        score,
+        reason,
+        title: entry.capability || entry.announcementId,
+        summary: entry.instructionPreview || '(无预览)',
+        budget: entry.budget ? `${entry.budget.maxAmount} ${entry.budget.currency}` : null,
+        matchTags,
+        createdAt: entry.createdAt ?? Date.now(),
+    };
+}
+/**
+ * 扫描 = **默认世界流 + 意图校准** (leo: 默认匹配状态, 不用先声明)。
+ *   · 无意图: 流入最近 open 公告 (新鲜度优先) —— 打开即有内容
+ *   · 有意图: 匹配(`match`)优先浮上来, 其余世界变化按新鲜度垫底 (世界不停)
+ *   · 已忽略的同源公告不流入 (随交互越来越准)
+ */
+export async function scanOpportunities(opts = {}) {
+    const limit = opts.limit ?? 50;
+    const minScore = opts.minScore ?? 0.2;
+    const intents = await listIntents();
+    if (!intents.ok)
+        return { ok: false, results: [], error: intents.error };
+    const active = intents.intents.filter((i) => i.status === 'active');
+    const fb = await readFeedback();
+    const board = await listBoard({ openOnly: true });
+    const openEntries = board.entries
+        .filter((e) => e.claimable && e.status === 'open')
+        .filter((e) => !fb.ignored.includes(e.announcementId)); // 校准: 忽略过的不再来
+    const now = Date.now();
+    if (!active.length) {
+        // 画像流: 有用户画像 → 画像标签当常驻意图 (reason=match, 初始化阶段的推送)
+        // 无画像 → 默认世界流 (新鲜度优先, 打开即有内容)
+        const profile = await readProfile();
+        const profileTags = profile?.tags?.filter((t) => t && t.length >= 2) ?? [];
+        if (profileTags.length) {
+            const matched = [];
+            for (const entry of openEntries) {
+                const oppText = `${entry.capability} ${entry.instructionPreview || ''}`;
+                const oppTags = tagsOf(oppText);
+                const to = tagOverlap(profileTags, oppTags);
+                const kh = keywordHit(profile?.about ?? '', oppText);
+                const bf = 0.5; // 画像无预算信息 → 中性
+                const score = 0.5 * to + 0.3 * kh + 0.2 * bf;
+                if (score < 0.15)
+                    continue;
+                matched.push(candidateOf(entry, null, Math.round(score * 100) / 100, 'match', profileTags.filter((t) => oppTags.includes(t))));
+            }
+            const matchedIds = new Set(matched.map((m) => m.sourceId));
+            const unmatched = openEntries
+                .filter((e) => !matchedIds.has(e.announcementId))
+                .map((e) => {
+                const ageDays = e.createdAt ? (now - e.createdAt) / 86400000 : 1;
+                const freshness = Math.max(0.3, Math.min(0.7, 1 - ageDays / 30));
+                return candidateOf(e, null, Math.round(freshness * 100) / 100, 'world', []);
+            });
+            const all = [...matched, ...unmatched].sort((a, b) => {
+                const rank = (r) => (r === 'match' ? 0 : 1);
+                if (rank(a.reason) !== rank(b.reason))
+                    return rank(a.reason) - rank(b.reason);
+                return b.score - a.score;
+            });
+            // 世界观察: 画像流看到的机会也记 memory
+            for (const c of all.filter((x) => x.reason === 'match').slice(0, 10)) {
+                void noteObservation({ ts: Date.now(), kind: 'opportunity-seen', sourceId: c.sourceId, title: c.title, score: c.score, reason: 'match' });
+            }
+            return { ok: true, results: all.slice(0, limit) };
+        }
+        // 默认世界流: 新鲜度优先
+        const sorted = [...openEntries].sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
+        const out = sorted.slice(0, limit).map((e) => {
+            const ageDays = e.createdAt ? (now - e.createdAt) / 86400000 : 1;
+            const freshness = Math.max(0.5, Math.min(0.95, 1 - ageDays / 30));
+            return candidateOf(e, null, Math.round(freshness * 100) / 100, 'world', []);
+        });
+        out.sort((a, b) => b.createdAt - a.createdAt || b.score - a.score);
+        // 世界观察: AI 睁眼看到的变化, 记进 memory (自动, 不是人触发)
+        for (const c of out.slice(0, 10)) {
+            void noteObservation({ ts: Date.now(), kind: 'world-change', sourceId: c.sourceId, title: c.title, score: c.score, reason: 'world' });
+        }
+        return { ok: true, results: out.slice(0, limit) };
+    }
+    // 有意图: 匹配打分, match 优先; 世界变化不消失
+    const matches = [];
+    for (const intent of active) {
+        for (const entry of openEntries) {
+            const oppText = `${entry.capability} ${entry.instructionPreview || ''}`;
+            const oppTags = tagsOf(oppText);
+            const to = tagOverlap(intent.tags, oppTags);
+            const kh = keywordHit(intent.text, oppText);
+            const bf = budgetFit(intent.budget, entry.budget ?? null);
+            const score = 0.5 * to + 0.3 * kh + 0.2 * bf;
+            if (score < minScore)
+                continue;
+            matches.push(candidateOf(entry, intent.id, Math.round(score * 100) / 100, 'match', intent.tags.filter((t) => oppTags.includes(t))));
+        }
+    }
+    const matchedIds = new Set(matches.map((m) => m.sourceId));
+    const unmatched = openEntries
+        .filter((e) => !matchedIds.has(e.announcementId))
+        .map((e) => {
+        const ageDays = e.createdAt ? (now - e.createdAt) / 86400000 : 1;
+        const freshness = Math.max(0.3, Math.min(0.7, 1 - ageDays / 30));
+        return candidateOf(e, null, Math.round(freshness * 100) / 100, 'world', []);
+    });
+    const all = [...matches, ...unmatched].sort((a, b) => {
+        const rank = (r) => (r === 'match' ? 0 : 1);
+        if (rank(a.reason) !== rank(b.reason))
+            return rank(a.reason) - rank(b.reason);
+        return b.score - a.score;
+    });
+    // 世界观察: 高分匹配 = AI 主动看到的机会 (自动记 memory)
+    for (const c of all.filter((x) => x.reason === 'match').slice(0, 10)) {
+        void noteObservation({ ts: Date.now(), kind: 'opportunity-seen', sourceId: c.sourceId, title: c.title, score: c.score, reason: 'match' });
+    }
+    return { ok: true, results: all.slice(0, limit) };
+}
+/** 对单个意图即时匹配 (list --intent 用; 不走反馈过滤) */
+export async function matchOneIntentText(text, tags, budget, opts = {}) {
+    const intent = {
+        id: 'int_adhoc', text, tags, priority: 3, budget,
+        deadline: null, status: 'active', createdAt: Date.now(), updatedAt: Date.now(), matchedCount: 0,
+    };
+    const board = await listBoard({ openOnly: true });
+    const openEntries = board.entries.filter((e) => e.claimable && e.status === 'open');
+    const out = [];
+    for (const entry of openEntries) {
+        const oppText = `${entry.capability} ${entry.instructionPreview || ''}`;
+        const oppTags = tagsOf(oppText);
+        const to = tagOverlap(intent.tags, oppTags);
+        const kh = keywordHit(intent.text, oppText);
+        const bf = budgetFit(intent.budget, entry.budget ?? null);
+        const score = 0.5 * to + 0.3 * kh + 0.2 * bf;
+        if (score < (opts.minScore ?? 0.2))
+            continue;
+        out.push(candidateOf(entry, intent.id, Math.round(score * 100) / 100, 'match', intent.tags.filter((t) => oppTags.includes(t))));
+    }
+    out.sort((x, y) => y.score - x.score || x.id.localeCompare(y.id));
+    return out.slice(0, opts.limit ?? 20);
+}

package/dist/agents/pi-sdk-tools.js

@@ -24,7 +24,7 @@ import { registerSkillShareTools } from './skill-share.js';
 // 2026-09-13: 微支付信息服务 (x402 付费信息 + 验真信封)
 import { registerPaidInfoTools } from './x402/paid-info-tools.js';
 // 2026-10-02: 群聊的四个 AI 工具 —— 原语来自群模块与"唯一发送出口"(带隐私闸)
-import { joinGroup, listGroups, groupLink, groupMessages, groupMembers } from './gateway-group.js';
+import { createGroup, joinGroup, listGroups, groupLink, groupMessages, groupMembers } from './gateway-group.js';
 import { resolveGroupRef, resolveSenderTag, sendTrailMessage } from './task-group.js';
 // 2026-10-02: 群聊自主回路 (读 → 自己判断 → 自己发言) —— AI 用 group_autopilot 工具驱动
 import { loadAutopilotState, runGroupAutopilotOnce, startGroupAutopilot } from './group-autopilot.js';
@@ -970,6 +970,25 @@ export function registerBuiltinTools(ctx) {
         return out.length ? out : undefined;
     };
     // 2026-10-02 (leo: 希望人工智能自己搞定): 群聊工具 —— 原语来自群模块 + 唯一发送出口(带隐私闸)
+    ctx.tools.set('group_create', {
+        name: 'group_create',
+        description: '新建一个 OrbitDB 群聊并拿到邀请链接 —— **用于**你要开一个话题把别人拉进来（建好后把邀请链接发出去, 对方用 group_join 入群）。acl 默认 creator: 只有你自己能发言; 想让**谁拿到链接都能发言**就传 acl="open"（产品语义如此, 两种都合法）。',
+        parameters: { name: '群名（必填）', acl: 'creator | open —— 默认 creator(创建者独占写入); open = 谁拿链接都能发言', from: '你的署名（可选; 默认本机身份）' },
+        execute: async (args) => {
+            const name = String(args?.name ?? '').trim();
+            if (!name)
+                return { success: false, error: 'name 必填（群名）' };
+            const who = await resolveSenderTag(null);
+            // 只认 'open'; 其它一律走产品默认 (创建者独占) —— 不猜、不替调用方放开权限
+            const acl = String(args?.acl ?? '').trim() === 'open' ? 'open' : undefined;
+            const r = await createGroup(name, { ...(who.ok ? { from: who.tag } : {}), ...(acl ? { acl } : {}) });
+            const g = r.group;
+            if (!g?.id)
+                return { success: false, error: '建群没返回 groupId（如实报告, 不假装成功）' };
+            const link = await groupLink(g.id).catch(() => null);
+            return { success: true, output: `已建群「${g.name}」(${g.id})${acl ? ' · 开放写入(谁拿链接都能发言)' : ' · 创建者独占写入'}\n` + (link ? `邀请链接: ${link}\n把这个链接发给对方, 他用 group_join 入群。` : '(没拿到邀请链接 —— 用 group_list 再看一次)') };
+        },
+    });
     ctx.tools.set('group_join', {
         name: 'group_join',
         description: '加入一个 OrbitDB 群聊 —— **用于**拿到邀请链接后自助入群（幂等: 已在群里 ⇒ already）。link 传邀请链接（orbitdb:///orbitdb/<addr>?type=group&name=…）或 groupId。入群后先用 group_read 读消息、再用 group_say 发言。',
@@ -1186,7 +1205,7 @@ export function registerBuiltinTools(ctx) {
     ctx.tools.set('group_autopilot', {
         name: 'group_autopilot',
         description: '群聊自主回路 —— **用于**让 AI 自己读群、自己判断该不该开口、自己在群里发言（不用人盯着）。action: run(立刻跑一轮) / start(挂成常驻, 每 intervalMs 一轮) / stop / status。默认只在「被 @」或「有人提问/请人做事」时说话, 冷却 60s、每小时每群最多 6 次, 处理过的消息不会重复回应。',
-        parameters: { action: 'run | start | stop | status（必填）', intervalMs: '常驻时的间隔 ms（默认 60000）', group: '只盯某个群（groupId/链接/群名, 可选; 缺省 = 全部已加入的群）' },
+        parameters: { action: 'run | start | stop | status（必填）', intervalMs: '常驻时的间隔 ms（默认 60000）', mode: 'quiet | active | maintenance（可选; maintenance 专门维护 Bolloon）', group: '只盯某个群（groupId/链接/群名, 可选; 缺省 = 全部已加入的群）' },
         execute: async (args) => {
             const action = String(args?.action ?? 'run').trim();
             const who = await resolveSenderTag(null);
@@ -1206,6 +1225,7 @@ export function registerBuiltinTools(ctx) {
                 readMessages: (gid, limit) => groupMessages(gid, limit),
                 speak: (gid, text, opts) => sendTrailMessage(gid, text, who.tag, opts ?? {}),
                 state,
+                policy: { mode: String(args?.mode ?? 'quiet') },
             };
             if (action === 'stop') {
                 if (!autopilotHandle)

package/dist/agents/pi-sdk.js

@@ -1099,7 +1099,14 @@ export class PiAgentSession {
                     return `[初始化未就绪] ${why}\n${hint}`;
                 }
             }
-            catch { /* 门禁自身异常 → 按"不能判定"处理会阻塞一切; 这里只在能读到状态时才拦 */ }
+            catch (err) {
+                // fail-closed: 门禁异常不能绕过初始化，否则会出现"身份未就绪但 Agent 已调用工具"。
+                const why = `初始化门禁读取失败: ${String(err?.message ?? err).slice(0, 240)}`;
+                this.pushHistory({ role: 'user', content: input });
+                this.pushHistory({ role: 'assistant', content: `[初始化未就绪] ${why}\n请运行 bolloon setup status；修复后再重试。` });
+                console.warn(`[PiAgent] 拒绝执行: ${why}`);
+                return `[初始化未就绪] ${why}\n请运行 bolloon setup status；修复后再重试。`;
+            }
         }
         this.minimaxAvailable = this.checkMinimax();
         this.actor.state.channelId = options?.channelId ?? this.actor.state.channelId;

package/dist/agents/world-profile.js

@@ -0,0 +1,49 @@
+/**
+ * world-profile.ts — 用户画像 (初始化阶段收集, 常驻意图)
+ *
+ * leo (2026-10-05) 三条分发规划之③: 结合用户画像推送 —— 初始化时 AI 获取
+ * 「你是谁/在做什么/标签」, 无 active intent 时画像标签当常驻意图参与匹配。
+ * 独立文件是为了避免 opportunity-match ↔ world-watcher 循环依赖。
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { worldDir } from './intent-store.js';
+const profileFile = () => path.join(worldDir(), 'profile.json');
+export async function readProfile() {
+    try {
+        const raw = await fs.readFile(profileFile(), 'utf-8');
+        const p = JSON.parse(raw);
+        if (!p || typeof p !== 'object')
+            return null;
+        return {
+            name: String(p.name || ''),
+            about: String(p.about || ''),
+            tags: Array.isArray(p.tags) ? p.tags.filter((t) => typeof t === 'string') : [],
+            updatedAt: Number(p.updatedAt) || Date.now(),
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** 写/更新用户画像 (初始化收集用) */
+export async function setProfile(input) {
+    const prev = await readProfile();
+    const profile = {
+        name: String(input.name ?? prev?.name ?? '').trim(),
+        about: String(input.about ?? prev?.about ?? '').trim(),
+        tags: Array.isArray(input.tags) ? input.tags.map((t) => String(t).trim()).filter(Boolean) : (prev?.tags ?? []),
+        updatedAt: Date.now(),
+    };
+    if (!profile.name && !profile.about && !profile.tags.length) {
+        return { ok: false, profile, error: '画像至少要有一个字段 (name/about/tags)' };
+    }
+    try {
+        await fs.mkdir(path.dirname(profileFile()), { recursive: true });
+        await fs.writeFile(profileFile(), JSON.stringify(profile, null, 2) + '\n', { mode: 0o600 });
+        return { ok: true, profile };
+    }
+    catch (err) {
+        return { ok: false, profile, error: String(err instanceof Error ? err.message : err) };
+    }
+}

package/dist/agents/world-watcher.js

@@ -0,0 +1,75 @@
+/**
+ * world-watcher.ts — 世界自动观察器 + 分发主体插槽 (2026-10-05, leo 三条分发规划)
+ *
+ * ① 自动触发机制: startWorldWatcher() 启动服务端定时扫描 —— AI 持续睁眼观察世界,
+ *    不依赖用户打开界面、不依赖按钮。丝滑 = 无人值守, 观察日志自己积累。
+ * ② 专门分发主体: 本地版分发主体 = 观察日志 (world/memory/events.jsonl) + 校准环。
+ *    未来云端模型/API/专门智能体群 = 换 `dispatchSink` 实现, 接口不变。
+ * ③ 用户画像推送: world/profile.json —— 初始化阶段收集 (你是谁/在做什么/标签),
+ *    作为常驻意图参与匹配: 无 active intent 时, 画像标签就是意图 (reason=match)。
+ */
+import { scanOpportunities } from './opportunity-match.js';
+import { readProfile, setProfile } from './world-profile.js';
+export { readProfile, setProfile };
+// ── 自动触发机制 (服务端定时扫描) ─────────────────────────────────────────────
+let watcherTimer = null;
+let watching = false; // 防重叠: 上一轮没跑完就跳过这一轮
+let watcherCount = 0;
+/** 单轮观察: 扫描世界 → 观察日志/校准环自动积累 (分发主体本地版) */
+export async function tickWorldWatcher() {
+    if (watching)
+        return { ok: true, observed: 0, count: watcherCount, error: '上一轮观察未完成, 跳过本轮 (防重叠)' };
+    watching = true;
+    try {
+        const r = await scanOpportunities({ limit: 50 });
+        watcherCount += 1;
+        return { ok: r.ok, observed: r.results.length, count: watcherCount, error: r.error };
+    }
+    finally {
+        watching = false;
+    }
+}
+/**
+ * 启动世界自动观察器 (服务端启动时调用一次即可; 幂等, 重复调用不叠定时器)。
+ * 每 intervalMs (默认 10 分钟) 自动扫描一次 —— 机会进入 AI 视野是主动行为, 不是人触发。
+ */
+export function startWorldWatcher(intervalMs = 10 * 60 * 1000) {
+    if (watcherTimer)
+        return { started: false, intervalMs };
+    watcherTimer = setInterval(() => {
+        void tickWorldWatcher().catch(() => { });
+    }, intervalMs);
+    // 启动后立刻睁眼一次 (不等第一个周期)
+    void tickWorldWatcher().catch(() => { });
+    return { started: true, intervalMs };
+}
+export function stopWorldWatcher() {
+    if (watcherTimer) {
+        clearInterval(watcherTimer);
+        watcherTimer = null;
+        return true;
+    }
+    return false;
+}
+export function worldWatcherStatus() {
+    return { running: !!watcherTimer, intervalMs: watcherTimer ? 10 * 60 * 1000 : 0, ticks: watcherCount };
+}
+let dispatchSink = null;
+/** 设置分发主体 (本地默认 = 无操作, 观察日志已是记录; 未来接云端 API 换这个) */
+export function setDispatchSink(sink) {
+    dispatchSink = sink;
+}
+export function getDispatchSink() {
+    return dispatchSink;
+}
+/** 手动触发一轮观察并走分发主体 (测试/CLI 用) */
+export async function observeWorldOnce() {
+    const r = await tickWorldWatcher();
+    if (dispatchSink && r.observed > 0) {
+        // 分发主体吃到的机会 (本地默认无操作; 云端版在这里把机会推给专门智能体群)
+        const board = await scanOpportunities({ limit: 20 });
+        if (board.ok)
+            await dispatchSink(board.results);
+    }
+    return r;
+}