@bolloon/bolloon-agent 0.6.3 → 0.6.4

package/README.md

@@ -1,11 +1,13 @@
 # Bolloon
 
-**一万个智能体，为你工作。**
+**一万个智能体的世界，走进你的世界。**
 
-Bolloon 是一台跑在你自己设备上的智能体。它有自己的身份（DID）、自己的记忆、自己的技能库，
-并且能在点对点网络里**找到别的智能体、把自己的活委派出去、按结果结算**。
+Bolloon 是一个多终端的 Agent 分发网络。它带来的不是一个更大更听话的助手，而是一万个智能体
+所在的世界——每个智能体都有自己的身份（DID）、自己的记忆、自己的技能库，并且能在点对点
+网络里**找到别的智能体、把自己的活委派出去、按结果结算**。
 
-不是「又一个聊天框」，而是**一个可以互相接手工作的智能体网络**。
+不是「又一个聊天框」，而是**一个可以互相接手工作的智能体世界，在不同设备上以不同方式分发**：
+PC 上创建、手机上发现、生活中相遇。
 
 > 官网 · https://bolloon.cn　｜　安装 · `npm i -g @bolloon/bolloon-agent`（[npm 上的最新版](https://www.npmjs.com/package/@bolloon/bolloon-agent)）
 
@@ -19,9 +21,10 @@ Bolloon 是一台跑在你自己设备上的智能体。它有自己的身份（
 Bolloon 把这件事变成网络问题：**每个智能体都有身份、技能和账本**，于是它可以被别的智能体
 发现、被委派、被结算——你只需要说清目标。
 
-这也是我们的方向：让 C 端用户在自己的电脑上，拥有一条**由很多智能体组成的生产线**，
-而不只是一个对话框。我自己每天用它做的事是**可控核聚变的研究**——线圈设计、仿真、验证、
-论文形式化，由不同智能体分头接手，我只看结论。
+这也是我们的方向：不是给你更多个对话框，而是让**一万个智能体所在的世界，走进你的世界**——
+你在自己的电脑上拥有一条由很多智能体组成的生产线，它跟着你用，而不是你跟着它学。
+我自己每天用它做的事是**可控核聚变的研究**——线圈设计、仿真、验证、论文形式化，
+由不同智能体分头接手，我只看结论。
 
 ---
 
@@ -89,7 +92,7 @@ docker run -d --name bolloon -p 127.0.0.1:54188:54188 \
 **已经稳定**：CLI 交互 · 技能库与提炼 · 工具调用与类型门 · 后台进程与服务管理 · 链上任务与结算 · P2P 发现与委派。
 
 **还在早期**：多智能体之间的**经济闭环**（谁付钱、怎么分账、争议怎么裁）只有最基础的一层；
-「一万个智能体」是方向，不是今天打开就能看到的数量。
+「一个装着上万智能体的世界走进你生活」是方向，不是今天打开就能看到的世界大小。
 
 **我们不说的话**：不承诺「全自动无需照看」；链上记录不可撤销；模型能力是上限，
 智能体不会超过它用的模型。
@@ -117,7 +120,7 @@ npm run build:all
 npm start
 ```
 
-跑测试：`npx vitest run`（当前 304 个文件 / 4609 个用例）。
+跑测试：`npx vitest run`（当前 342 个文件 / 4752 个用例）。
 改了 TypeScript 后：`npx tsc --noEmit`。
 
 ---
@@ -132,13 +135,15 @@ MIT。见 [LICENSE](./LICENSE)。
 
 # Bolloon (English)
 
-**Ten thousand agents, working for you.**
+**A world of ten thousand agents, stepping into yours.**
 
-Bolloon is an agent that runs on your own machine. It has its own identity (DID), its own memory and
-its own library of skills, and it can **find other agents on a peer-to-peer network, hand work over,
-and settle by result**.
+Bolloon is a multi-device agent distribution network. It brings not a bigger, more obedient assistant,
+but a world where ten thousand agents live — each with its own identity (DID), its own memory and its
+own library of skills, able to **find other agents on a peer-to-peer network, hand work over, and
+settle by result**.
 
-Not "yet another chat box" — **a network of agents that can take over each other's work.**
+Not "yet another chat box" — **a world of agents that can take over each other's work, distributed
+differently on each device**: created on PC, discovered on phone, met in life.
 
 > Website · https://bolloon.cn　｜　Install · `npm i -g @bolloon/bolloon-agent`（[latest on npm](https://www.npmjs.com/package/@bolloon/bolloon-agent)）
 
@@ -150,8 +155,9 @@ roles: someone researches, someone writes, someone verifies, someone makes sure
 Bolloon turns that into a network problem. Every agent has an identity, skills and a ledger, so it can
 be discovered, delegated to and paid. You only have to state the goal.
 
-That is the direction: a **production line made of many agents**, running on a consumer machine —
-not a single dialogue box. I use it every day for **controlled nuclear fusion** research.
+That is the direction: not more chat boxes, but **a world of ten thousand agents stepping into yours**
+— a production line made of many agents, running on a consumer machine, following you rather than
+you following it. I use it every day for **controlled nuclear fusion** research.
 
 ## What works today
 
@@ -182,7 +188,8 @@ Node.js ≥ 18. First run walks you through picking a model provider.
 
 **Stable**: CLI · skills · tool calling · background services · on-chain tasks · P2P discovery and
 delegation.　**Early**: the economics between agents (who pays, how it splits, how disputes resolve).
-"Ten thousand agents" is a direction, not a number you will see on day one.
+"A world of ten thousand agents entering your life" is a direction, not the world-size you will see
+on day one.
 
 **What we will not claim**: fully unattended operation; reversible on-chain records; capability beyond
 the model you plug in.

package/dist/agents/intent-store.js

@@ -0,0 +1,193 @@
+/**
+ * intent-store.ts — Intent Store (2026-10-05, leo 四端 Intent Network 设计 P0)
+ *
+ * Intent = Goal 的**前身**: 一句话「我正在做 X」+ 标签/预算/期限, 未到可执行程度。
+ * 它与 goal-flywheel 的 Goal 不冲突 (Goal 是意图的可执行投影):
+ *   · intent 是轻量声明 (world/intents/ 一意图一文件)
+ *   · 升级成可执行意图时 → 转 Goal (goal-flywheel)
+ * 接口层不重叠, 本模块不碰 goal-store。
+ *
+ * 存储布局 (leo: 「intents 专门设计一个文件夹」「world 也是设计文件夹更好」):
+ *   ~/.bolloon/world/               ← World 根 (六元组本体的实体根)
+ *     ├── intents/                  ← Intent 实体目录 (一意图一文件, 原子写)
+ *     │   └── int_<id>.json
+ *     ├── opportunities/            ← (P1) Opportunity 实体目录
+ *     ├── actions/                  ← (后续) Action 实体目录
+ *     └── memory/                   ← (后续) Memory 实体目录
+ * 每个实体独立文件 ⇒ 原子写 / 并发安全 / 可扩展, 与 task-board 的 announcement 文件模式同源。
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import * as crypto from 'crypto';
+const homeOf = (home) => home || process.env.HOME || os.homedir();
+/** World 根目录 (~/.bolloon/world/) */
+export const worldDir = (home) => path.join(homeOf(home), '.bolloon', 'world');
+/** Intent 实体目录 (~/.bolloon/world/intents/) */
+export const intentsDir = (home) => path.join(worldDir(home), 'intents');
+/** Opportunity 实体目录 (~/.bolloon/world/opportunities/, P1) */
+export const opportunitiesDir = (home) => path.join(worldDir(home), 'opportunities');
+/** 只允许 int_ 开头的 id 当文件名 (防路径穿越); 非法 → null */
+function safeId(id) {
+    const s = String(id || '').trim();
+    return /^int_[A-Za-z0-9]{6,32}$/.test(s) ? s : null;
+}
+/** 意图文件路径 (非法 id → null) */
+export function intentFile(id, home) {
+    const safe = safeId(id);
+    return safe ? path.join(intentsDir(home), `${safe}.json`) : null;
+}
+async function ensure(dir) {
+    try {
+        await fs.mkdir(dir, { recursive: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function writeJson(file, value) {
+    try {
+        await ensure(path.dirname(file));
+        await fs.writeFile(file, JSON.stringify(value, null, 2) + '\n', { mode: 0o600 });
+        return { ok: true };
+    }
+    catch (e) {
+        return { ok: false, error: String(e?.message || e).slice(0, 200) };
+    }
+}
+async function readJson(file) {
+    try {
+        const raw = await fs.readFile(file, 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object')
+            return { ok: false, error: `${path.basename(file)} 不是对象` };
+        return { ok: true, value: parsed };
+    }
+    catch (e) {
+        if (e?.code === 'ENOENT')
+            return { ok: false, error: 'ENOENT' };
+        return { ok: false, error: `读 ${path.basename(file)} 失败: ${String(e?.message || e).slice(0, 120)}` };
+    }
+}
+/** 标签: 从意图正文提取简单标签 (英文词 + 中文 2 字以上词元) + 手工标签去重 */
+export function extractTags(text, manual = []) {
+    const src = String(text || '').toLowerCase();
+    const words = src.match(/[a-z][a-z0-9_-]{1,}/g) || [];
+    const cjk = src.match(/[\u4e00-\u9fff]{2,}/g) || [];
+    const all = [...words, ...cjk, ...manual.map((t) => t.toLowerCase().trim()).filter(Boolean)];
+    return Array.from(new Set(all)).slice(0, 24);
+}
+/** 扫描 intents 目录, 列出全部意图 (按创建时间倒序) */
+export async function listIntents(home, status) {
+    const dir = intentsDir(home);
+    let entries;
+    try {
+        entries = await fs.readdir(dir);
+    }
+    catch (e) {
+        if (e?.code === 'ENOENT')
+            return { ok: true, intents: [] };
+        return { ok: false, intents: [], error: `读 ${dir} 失败: ${String(e?.message || e).slice(0, 120)}` };
+    }
+    const intents = [];
+    for (const name of entries.filter((n) => n.startsWith('int_') && n.endsWith('.json'))) {
+        const r = await readJson(path.join(dir, name));
+        if (!r.ok || !r.value || !r.value.id)
+            continue; // 坏文件跳过, 不崩
+        intents.push(r.value);
+    }
+    intents.sort((a, b) => b.createdAt - a.createdAt);
+    return { ok: true, intents: status ? intents.filter((i) => i.status === status) : intents };
+}
+/** 单条意图按 id 读 (不存在 → ok:true 无 intent) */
+export async function getIntent(id, home) {
+    const file = intentFile(id, home);
+    if (!file)
+        return { ok: false, error: `非法意图 id: ${String(id).slice(0, 32)}` };
+    const r = await readJson(file);
+    if (!r.ok)
+        return r.error === 'ENOENT' ? { ok: true } : r;
+    return { ok: true, intent: r.value };
+}
+/** 声明意图 (幂等: 同 text 已存在 → 更新 tags/priority, 不重复建文件) */
+export async function setIntent(input) {
+    const text = String(input.text || '').trim();
+    if (!text)
+        return { ok: false, created: false, error: '意图不能为空' };
+    const priority = input.priority ?? 3;
+    if (!Number.isInteger(priority) || priority < 1 || priority > 5)
+        return { ok: false, created: false, error: `priority 必须 1-5 整数, 实得 ${String(priority)}` };
+    const loaded = await listIntents(input.home);
+    if (!loaded.ok)
+        return { ok: false, created: false, error: loaded.error };
+    const now = Date.now();
+    const existing = loaded.intents.find((i) => i.text === text && i.status === 'active');
+    if (existing) {
+        const merged = {
+            ...existing,
+            tags: extractTags(text, [...(input.tags ?? []), ...existing.tags]),
+            priority,
+            budget: input.budget !== undefined ? input.budget : existing.budget,
+            deadline: input.deadline !== undefined ? input.deadline : existing.deadline,
+            updatedAt: now,
+        };
+        const file = intentFile(existing.id, input.home);
+        if (!file)
+            return { ok: false, created: false, error: '非法 id' };
+        const saved = await writeJson(file, merged);
+        if (!saved.ok)
+            return { ok: false, created: false, error: saved.error };
+        return { ok: true, intent: merged, created: false };
+    }
+    const record = {
+        id: `int_${crypto.randomBytes(6).toString('hex')}`,
+        text, tags: extractTags(text, input.tags ?? []), priority,
+        budget: input.budget ?? null, deadline: input.deadline ?? null,
+        status: 'active', createdAt: now, updatedAt: now, matchedCount: 0,
+    };
+    const file = intentFile(record.id, input.home);
+    if (!file)
+        return { ok: false, created: false, error: '非法 id' };
+    const saved = await writeJson(file, record);
+    if (!saved.ok)
+        return { ok: false, created: false, error: saved.error };
+    return { ok: true, intent: record, created: true };
+}
+/** 删意图 (或标记 done) */
+export async function removeIntent(id, markDone = false, home) {
+    const file = intentFile(id, home);
+    if (!file)
+        return { ok: false, error: `非法意图 id: ${String(id).slice(0, 32)}` };
+    if (markDone) {
+        const r = await getIntent(id, home);
+        if (!r.ok)
+            return { ok: false, error: r.error };
+        if (!r.intent)
+            return { ok: false, error: `没有意图 ${id} (看 bolloon intent list)` };
+        const updated = { ...r.intent, status: 'done', updatedAt: Date.now() };
+        const saved = await writeJson(file, updated);
+        if (!saved.ok)
+            return { ok: false, error: saved.error };
+        return { ok: true, removed: id };
+    }
+    try {
+        await fs.unlink(file);
+        return { ok: true, removed: id };
+    }
+    catch (e) {
+        if (e?.code === 'ENOENT')
+            return { ok: false, error: `没有意图 ${id} (看 bolloon intent list)` };
+        return { ok: false, error: `删 ${file} 失败: ${String(e?.message || e).slice(0, 120)}` };
+    }
+}
+/** 意图匹配数 +1 (扫描后被上层调用, 诚实计数) */
+export async function bumpMatchedCount(id, home) {
+    const r = await getIntent(id, home);
+    if (!r.ok || !r.intent)
+        return;
+    const updated = { ...r.intent, matchedCount: r.intent.matchedCount + 1, updatedAt: Date.now() };
+    const file = intentFile(id, home);
+    if (file)
+        await writeJson(file, updated);
+}

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/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;
+}