@bolloon/bolloon-agent 0.6.3 → 0.6.5

package/dist/agents/opportunity-match.js

@@ -0,0 +1,301 @@
+/**
+ * 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`)优先浮上来, 其余世界变化按新鲜度垫底 (世界不停)
+ *   · 已忽略的同源公告不流入 (随交互越来越准)
+ *   · 机会信箱 (外部 agent 投递, 验签通过) 恒优先 —— 真实可信来源
+ */
+async function mergeInboxOnTop(all) {
+    const { listInboxOpportunities } = await import('./opportunity-inbox.js');
+    const inboxOpps = await listInboxOpportunities();
+    const inboxCards = inboxOpps
+        .filter((o) => o.verification === 'verified') // 只放行验签通过的
+        .map((o) => ({
+        id: o.id,
+        intentId: null,
+        source: 'inbox',
+        sourceId: o.id,
+        score: 0.9,
+        reason: 'inbox',
+        title: o.title,
+        summary: o.summary,
+        budget: null,
+        matchTags: [],
+        createdAt: o.receivedAt,
+        inbox: { providerDid: o.provider.did, providerName: o.provider.name, verification: o.verification, refs: o.refs },
+    }));
+    for (const c of inboxCards.slice(0, 10)) {
+        void noteObservation({ ts: Date.now(), kind: 'opportunity-seen', sourceId: c.sourceId, title: c.title, score: c.score, reason: 'inbox' });
+    }
+    // 2026-10-05: AI 主动上网搜到的机会 (真 URL, 可点开核实) — 排信箱后、本地源前
+    const { listSearchOpportunities } = await import('./opportunity-web-search.js');
+    const searchOpps = await listSearchOpportunities();
+    const searchCards = searchOpps.map((o) => ({
+        id: o.id,
+        intentId: null,
+        source: 'search',
+        sourceId: o.id,
+        score: 0.8,
+        reason: 'search',
+        title: o.title,
+        summary: o.summary,
+        budget: null,
+        matchTags: [],
+        createdAt: o.searchedAt,
+        search: { url: o.url, source: o.source, query: o.query },
+    }));
+    for (const c of searchCards.slice(0, 10)) {
+        void noteObservation({ ts: Date.now(), kind: 'opportunity-seen', sourceId: c.sourceId, title: c.title, score: c.score, reason: 'search' });
+    }
+    return [...inboxCards, ...searchCards, ...all]; // 信箱 > 搜索 > 本地
+}
+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: (await mergeInboxOnTop(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: (await mergeInboxOnTop(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;
+    });
+    return { ok: true, results: (await mergeInboxOnTop(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/opportunity-web-search.js

@@ -0,0 +1,183 @@
+/**
+ * opportunity-web-search.ts — AI 主动上网搜机会 (2026-10-05, leo: 系统要主动搜索展示)
+ *
+ * 设计: 世界观察器 (world-watcher) 每轮 tick 时, 若有 active intent / 用户画像,
+ *   自动用 DuckDuckGo 搜索「<意图> + 合作/机会/招募/开放」类关键词, 把真搜索结果
+ *   结构化落盘 `~/.bolloon/world/search/<id>.json`, 并进世界流 (reason=search, 带来源 URL)。
+ *
+ * 真实可信: 每条 = 真 URL + 真摘要 (来自搜索返回), 可点开核实, 不是本机编造。
+ * 无 TAVILY_API_KEY 时走 DuckDuckGo HTML 端点 (免费无需 key, 与本仓 fetch_url 同源 curl 模式)。
+ */
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as crypto from 'node:crypto';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { worldDir } from './intent-store.js';
+const pExecFile = promisify(execFile);
+const searchDir = () => path.join(worldDir(), 'search');
+function safeId(s) {
+    return s.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+}
+/** DuckDuckGo HTML 搜索 → 结构化结果 (标题/URL/摘要) */
+async function searchDuckDuckGo(query, limit = 8) {
+    try {
+        const UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36';
+        const { stdout } = await pExecFile('curl', [
+            '-sL', '--max-time', '20', '-A', UA,
+            '-H', 'Accept-Language: zh-CN,zh;q=0.9,en;q=0.8',
+            `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`,
+        ], { maxBuffer: 2 * 1024 * 1024, timeout: 25_000 });
+        if (!stdout)
+            return [];
+        // 解析 result__a (标题+URL) + result__snippet (摘要)
+        const out = [];
+        const itemRe = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>[\s\S]*?<a[^>]*class="result__snippet"[^>]*>(.*?)<\/a>/g;
+        let m;
+        let guard = 0;
+        while ((m = itemRe.exec(stdout)) !== null && guard++ < 30) {
+            const rawHref = m[1];
+            // DDG 的 href 是重定向包装 (//duckduckgo.com/l/?uddg=<encoded>)
+            let url = rawHref;
+            const uddg = rawHref.match(/uddg=([^&]+)/);
+            if (uddg) {
+                try {
+                    url = decodeURIComponent(uddg[1]);
+                }
+                catch {
+                    url = rawHref;
+                }
+            }
+            if (!/^https?:\/\//i.test(url))
+                continue;
+            const title = m[2].replace(/<[^>]+>/g, '').trim();
+            const summary = m[3].replace(/<[^>]+>/g, '').replace(/&[a-z]+;/g, ' ').replace(/\s+/g, ' ').trim();
+            if (title)
+                out.push({ title, url, summary: summary.slice(0, 200) });
+            if (out.length >= limit)
+                break;
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+/** Tavily 搜索 (配置了 TAVILY_API_KEY 时用, 更完整) */
+async function searchTavily(query, limit = 8) {
+    const key = process.env.TAVILY_API_KEY || '';
+    if (!key)
+        return [];
+    try {
+        const UA = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36';
+        const { stdout } = await pExecFile('curl', [
+            '-s', '--max-time', '20', '-A', UA,
+            '-X', 'POST', 'https://api.tavily.com/search',
+            '-H', 'Content-Type: application/json',
+            '-d', JSON.stringify({ api_key: key, query, max_results: limit, include_answer: false }),
+        ], { maxBuffer: 2 * 1024 * 1024, timeout: 25_000 });
+        const d = JSON.parse(stdout);
+        return (d.results || []).slice(0, limit).map((x) => ({
+            title: String(x.title || '').trim(),
+            url: String(x.url || '').trim(),
+            summary: String(x.content || '').replace(/\s+/g, ' ').slice(0, 200),
+        })).filter((x) => x.title && /^https?:/.test(x.url));
+    }
+    catch {
+        return [];
+    }
+}
+/** 搜索查询构造: 意图/画像 + 机会类词 (真搜索, 关键词可配) */
+const OPPORTUNITY_HINTS = ['合作', '机会', '招募', 'open call', 'partnership', 'looking for', 'call for'];
+function buildQueries(topic) {
+    const base = String(topic || '').trim().slice(0, 60);
+    if (!base)
+        return [];
+    return OPPORTUNITY_HINTS.map((h) => `${base} ${h}`);
+}
+/**
+ * 主动搜索一轮: 按 topic (意图/画像文本) 搜机会, 结构化落盘。
+ * 返回本轮新增条数 (已有同 URL 的不重复落盘 — 幂等)。
+ */
+export async function searchOpportunitiesForTopic(topic, opts = {}) {
+    const limit = opts.limit ?? 6;
+    const queries = buildQueries(topic);
+    if (!queries.length)
+        return { ok: false, added: 0, total: 0, results: [], error: '空 topic' };
+    // 合并引擎结果 (Tavily 优先, 无 key 走 DDG)
+    const engine = process.env.TAVILY_API_KEY ? searchTavily : searchDuckDuckGo;
+    const raw = [];
+    for (const q of queries.slice(0, 3)) {
+        const hits = await engine(q, limit);
+        for (const h of hits)
+            raw.push({ ...h, query: q });
+    }
+    // 已有 URL 集合 (幂等)
+    const seen = new Set();
+    try {
+        const files = await fs.readdir(searchDir());
+        for (const f of files) {
+            if (!f.endsWith('.json'))
+                continue;
+            try {
+                const p = JSON.parse(await fs.readFile(path.join(searchDir(), f), 'utf-8'));
+                if (p && p.url)
+                    seen.add(String(p.url));
+            }
+            catch { /* 坏文件跳过 */ }
+        }
+    }
+    catch { /* 目录不存在 = 首次 */ }
+    const now = Date.now();
+    const results = [];
+    let added = 0;
+    try {
+        await fs.mkdir(searchDir(), { recursive: true });
+    }
+    catch { /* 落盘失败不阻断 */ }
+    for (const r of raw) {
+        if (seen.has(r.url))
+            continue; // 已有, 不重复
+        const id = `search_${safeId(crypto.createHash('sha256').update(r.url).digest('hex').slice(0, 14))}`;
+        const opp = {
+            id,
+            query: r.query,
+            title: r.title.slice(0, 80),
+            url: r.url,
+            summary: r.summary,
+            source: process.env.TAVILY_API_KEY ? 'tavily' : 'duckduckgo',
+            searchedAt: now,
+        };
+        try {
+            await fs.writeFile(path.join(searchDir(), `${id}.json`), JSON.stringify(opp, null, 2) + '\n', { mode: 0o600 });
+            seen.add(r.url);
+            results.push(opp);
+            added += 1;
+        }
+        catch { /* 单条失败跳过 */ }
+        if (added >= limit)
+            break;
+    }
+    return { ok: true, added, total: results.length, results };
+}
+/** 列出已搜索到的机会 (最近在前) */
+export async function listSearchOpportunities() {
+    try {
+        const files = await fs.readdir(searchDir());
+        const out = [];
+        for (const f of files) {
+            if (!f.endsWith('.json'))
+                continue;
+            try {
+                const p = JSON.parse(await fs.readFile(path.join(searchDir(), f), 'utf-8'));
+                if (p && p.id && p.url)
+                    out.push(p);
+            }
+            catch { /* 坏文件跳过 */ }
+        }
+        return out.sort((a, b) => b.searchedAt - a.searchedAt);
+    }
+    catch {
+        return [];
+    }
+}

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,104 @@
+/**
+ * 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;
+/** 单轮观察: 扫描世界 → 观察日志/校准环自动积累 (分发主体本地版)。
+ *  2026-10-05 (leo): 有 active intent / 画像时, 自动上网搜机会 (AI 主动搜索, 非被动响应)。 */
+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;
+        // 2026-10-05: 主动搜索 — 有意图/画像才搜 (无 topic 不烧网络); 失败不影响扫描
+        await autoSearchForIntents();
+        return { ok: r.ok, observed: r.results.length, count: watcherCount, error: r.error };
+    }
+    finally {
+        watching = false;
+    }
+}
+/** 按 active intent + 画像文本自动搜索机会 (AI 主动上网找, 结果进 world/search/) */
+async function autoSearchForIntents() {
+    try {
+        const { listIntents } = await import('./intent-store.js');
+        const intents = await listIntents();
+        const active = intents.ok ? intents.intents.filter((i) => i.status === 'active') : [];
+        const topics = active.map((i) => i.text);
+        if (!topics.length) {
+            const profile = await readProfile();
+            if (profile && (profile.about || profile.tags.length)) {
+                topics.push(profile.about || profile.tags.join(' '));
+            }
+        }
+        if (!topics.length)
+            return; // 无意图无画像 → 不主动搜
+        // 每轮至多搜 2 个主题 (网络调用有成本; 已有结果幂等不重复)
+        for (const t of topics.slice(0, 2)) {
+            const { searchOpportunitiesForTopic } = await import('./opportunity-web-search.js');
+            const r = await searchOpportunitiesForTopic(t, { limit: 4 });
+            if (r.added > 0) {
+                console.info(`[world-watcher] 主动搜索「${t.slice(0, 30)}」新增 ${r.added} 条机会`);
+            }
+        }
+    }
+    catch { /* 主动搜索失败静默, 下一轮再试 */ }
+}
+/**
+ * 启动世界自动观察器 (服务端启动时调用一次即可; 幂等, 重复调用不叠定时器)。
+ * 每 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;
+}