@bolloon/bolloon-agent 0.4.0 → 0.4.3

package/dist/cron/cron-parser.js

@@ -0,0 +1,142 @@
+/**
+ * cron-parser.ts — cron 表达式 / 间隔解析 + 下次运行时间计算
+ *
+ * 借鉴 Hermes agent cron/scheduler.py 的调度心智:
+ *   - 支持标准 5 段 cron ("0 8 * * *") 与人类可读间隔 ("every 30m", "1h", "30s")
+ *   - 纯函数, 无 IO, 可单测: parseSchedule(schedule, from) → 下次触发 Date
+ *   - schedule 为空 / 解析失败 → 返回 null (调用方决定不调度或报错)
+ */
+/** "every 30m" / "every 1h" / "30s" / "1h" / "90s" → 毫秒; 其它返回 null */
+function _parseIntervalMs(raw) {
+    const m = raw.toLowerCase().trim().match(/^every\s+(\d+)\s*(s|m|h|d)?$|^(\d+)\s*(s|m|h|d)$/);
+    if (!m)
+        return null;
+    const num = Number(m[1] ?? m[3]);
+    const unit = (m[2] ?? m[4]) || 'm';
+    const mult = { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 };
+    return num * mult[unit];
+}
+/** 把 5 段 cron 拆成字段集合. 支持 *, 数字, 逗号, 范围, 步进 (仅分钟/小时/月/周日). */
+function _parseCronFields(expr) {
+    const parts = expr.trim().split(/\s+/);
+    if (parts.length !== 5)
+        return null;
+    const parse = (field, lo, hi) => {
+        const set = new Set();
+        for (const seg of field.split(',')) {
+            if (seg === '*') {
+                for (let v = lo; v <= hi; v++)
+                    set.add(v);
+                continue;
+            }
+            let step = 1;
+            let range = seg;
+            if (seg.includes('/')) {
+                const [r, s] = seg.split('/');
+                range = r;
+                step = Number(s) || 1;
+            }
+            let start = lo, end = hi;
+            if (range === '*') {
+                start = lo;
+                end = hi;
+            }
+            else if (range.includes('-')) {
+                const [a, b] = range.split('-');
+                start = Number(a);
+                end = Number(b);
+            }
+            else {
+                start = end = Number(range);
+            }
+            if (Number.isNaN(start) || Number.isNaN(end) || Number.isNaN(step))
+                return null;
+            for (let v = start; v <= end; v += step)
+                set.add(v);
+        }
+        return set;
+    };
+    const min = parse(parts[0], 0, 59);
+    const hour = parse(parts[1], 0, 23);
+    const dom = parse(parts[2], 1, 31);
+    const mon = parse(parts[3], 1, 12);
+    const dow = parse(parts[4], 0, 6);
+    if (!min || !hour || !dom || !mon || !dow)
+        return null;
+    return { min, hour, dom, mon, dow };
+}
+function _matchesCron(d, f) {
+    const domMatch = f.dom.has(d.getDate());
+    const dowMatch = f.dow.has(d.getDay());
+    // 经典 cron 语义: dom 与 dow 都受限时用 OR, 否则各自 AND
+    const domRestricted = !f.dom.has(31) && f.dom.size < 31;
+    const dowRestricted = f.dow.size < 7;
+    const dayOk = domRestricted && dowRestricted ? domMatch || dowMatch : domMatch && dowMatch;
+    return (dayOk &&
+        f.mon.has(d.getMonth() + 1) &&
+        f.hour.has(d.getHours()) &&
+        f.min.has(d.getMinutes()));
+}
+/**
+ * 解析 schedule 并计算下次触发时间.
+ * @param schedule "0 8 * * *" / "every 30m" / "1h" / "30s"
+ * @param from 基准时间 (默认 now)
+ * @returns ParsedSchedule 或 null (无法解析 / 未来 1 年内无匹配)
+ */
+export function parseSchedule(schedule, from = new Date()) {
+    const raw = (schedule || '').trim();
+    if (!raw)
+        return null;
+    // 间隔形式 (最快路径)
+    const intervalMs = _parseIntervalMs(raw);
+    if (intervalMs != null && intervalMs > 0) {
+        return { kind: 'interval', intervalMs, next: new Date(from.getTime() + intervalMs) };
+    }
+    // 5 段 cron: 从 from 起逐分钟扫描, 找下一个匹配 (上限 1 年避免死循环)
+    const fields = _parseCronFields(raw);
+    if (!fields)
+        return null;
+    const cursor = new Date(from);
+    cursor.setSeconds(0, 0);
+    cursor.setMinutes(cursor.getMinutes() + 1); // 严格 "下一次", 不含当前分
+    const capMs = from.getTime() + 366 * 86_400_000;
+    while (cursor.getTime() < capMs) {
+        if (_matchesCron(cursor, fields)) {
+            return { kind: 'cron', expr: raw, next: cursor, fields };
+        }
+        cursor.setMinutes(cursor.getMinutes() + 1);
+    }
+    return null;
+}
+/**
+ * 刷新一次调度: 给定 schedule 与上次触发, 返回本次应跑的触发点.
+ *   间隔型 → 以 lastRunAt 为基准叠加; 无 lastRunAt (首次) → 立即 due (返回 now).
+ *   cron 型 → 从 max(lastRunAt, now) 起找匹配; 上次触发已过期 → 立即 due.
+ */
+export function nextAfter(schedule, lastRunAt, now = new Date()) {
+    const raw = (schedule || '').trim();
+    if (!raw)
+        return null;
+    const intervalMs = _parseIntervalMs(raw);
+    if (intervalMs != null && intervalMs > 0) {
+        if (!lastRunAt)
+            return now; // 首次: 立即触发
+        return new Date(lastRunAt.getTime() + intervalMs);
+    }
+    // cron 型: 依托上次触发后的下一次, 与"当前墙钟"比较
+    const fields = _parseCronFields(raw);
+    if (!fields)
+        return null;
+    const base = lastRunAt && lastRunAt > now ? new Date(lastRunAt) : new Date(now);
+    base.setSeconds(0, 0);
+    let cursor = new Date(base);
+    if (lastRunAt)
+        cursor.setMinutes(cursor.getMinutes() + 1); // 严格晚于上次触发
+    const capMs = base.getTime() + 366 * 86_400_000;
+    while (cursor.getTime() < capMs) {
+        if (_matchesCron(cursor, fields))
+            return cursor;
+        cursor.setMinutes(cursor.getMinutes() + 1);
+    }
+    return null;
+}

package/dist/cron/jobs-store.js

@@ -0,0 +1,96 @@
+/**
+ * jobs-store.ts — 定时任务 (schedule jobs) 持久化
+ *
+ * 借鉴 Hermes agent cron/scheduler.py 心智:
+ *   - 每条 job 有: id / name / schedule (cron 或 every N) / prompt (执行体) / enabled
+ *   - 记录 lastRunAt / runCount, 调度器 tick 时找出 due 的 job 执行
+ *   - 落盘 ~/.bolloon/cron-jobs.json, 进程内互斥链序列化 + 临时文件原子写
+ *   - 不建数据库, 不引入外部调度系统 —— 单文件 + 内存互斥
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import * as crypto from 'crypto';
+function getJobsPath(home = os.homedir()) {
+    return path.join(home, '.bolloon', 'cron-jobs.json');
+}
+let jobsLock = Promise.resolve();
+function withLock(fn) {
+    const run = jobsLock.then(fn);
+    jobsLock = run.then(() => undefined, () => undefined);
+    return run;
+}
+async function readAll(home) {
+    try {
+        const raw = await fs.readFile(getJobsPath(home), 'utf-8');
+        const p = JSON.parse(raw);
+        if (p?.version === 1 && Array.isArray(p.jobs))
+            return p;
+        return { version: 1, jobs: [] };
+    }
+    catch {
+        return { version: 1, jobs: [] };
+    }
+}
+async function writeAll(file, home) {
+    const p = getJobsPath(home);
+    await fs.mkdir(path.dirname(p), { recursive: true });
+    const tmp = p + '.tmp';
+    await fs.writeFile(tmp, JSON.stringify(file, null, 2), 'utf-8');
+    await fs.rename(tmp, p);
+}
+export async function addJob(input, home = os.homedir()) {
+    return withLock(async () => {
+        const file = await readAll(home);
+        const job = {
+            id: crypto.randomUUID(),
+            name: input.name,
+            schedule: input.schedule,
+            prompt: input.prompt,
+            enabled: true,
+            createdAt: new Date().toISOString(),
+            runCount: 0,
+        };
+        file.jobs.push(job);
+        await writeAll(file, home);
+        return job;
+    });
+}
+export async function listJobs(home = os.homedir()) {
+    return withLock(async () => (await readAll(home)).jobs);
+}
+export async function removeJob(id, home = os.homedir()) {
+    return withLock(async () => {
+        const file = await readAll(home);
+        const before = file.jobs.length;
+        file.jobs = file.jobs.filter((j) => j.id !== id);
+        if (file.jobs.length === before)
+            return false;
+        await writeAll(file, home);
+        return true;
+    });
+}
+export async function setEnabled(id, enabled, home = os.homedir()) {
+    return withLock(async () => {
+        const file = await readAll(home);
+        const job = file.jobs.find((j) => j.id === id);
+        if (!job)
+            return null;
+        job.enabled = enabled;
+        await writeAll(file, home);
+        return job;
+    });
+}
+/** 标记已运行: 更新 lastRunAt + runCount (runId 用于并行保护, 由 scheduler 提供) */
+export async function markRun(id, at, home = os.homedir()) {
+    return withLock(async () => {
+        const file = await readAll(home);
+        const job = file.jobs.find((j) => j.id === id);
+        if (!job)
+            return null;
+        job.lastRunAt = at;
+        job.runCount += 1;
+        await writeAll(file, home);
+        return job;
+    });
+}

package/dist/cron/scheduler.js

@@ -0,0 +1,72 @@
+/**
+ * scheduler.ts — 定时任务调度器
+ *
+ * 借鉴 Hermes agent cron/scheduler.py 心智:
+ *   - 一个 tick() 扫描全部 enabled jobs, 用 parseSchedule 判断是否 due (下次时间 <= now)
+ *   - due → 执行 exec(job), 完成后 markRun 更新 lastRunAt
+ *   - 并发保护: 正在运行的 jobId 集合, 避免同一 job 并行重复触发
+ *   - exec 可注入: bolloon CLI 里把 job.prompt 投给 agent 调度闭环, 测试里可注入 fake
+ *   - 不建数据库, 不引入外部调度 —— 由调用方 (CLI 主循环) 定期调 tick()
+ */
+import * as os from 'os';
+import { listJobs, markRun } from './jobs-store.js';
+import { parseSchedule, nextAfter } from './cron-parser.js';
+export class Scheduler {
+    exec;
+    now;
+    home;
+    /** 正在运行的 job id, 防止并行重复触发 */
+    running = new Set();
+    /** 已触发但执行失败, 待下次重试 (避免死循环 + 可观测) */
+    failed = new Map();
+    constructor(opts) {
+        this.exec = opts.exec;
+        this.now = opts.now ?? (() => new Date());
+        this.home = opts.home ?? os.homedir();
+    }
+    /** 是否正在运行某 job (供外部查询并发状态) */
+    isRunning(jobId) {
+        return this.running.has(jobId);
+    }
+    /**
+     * 一次调度心跳. 找出所有 due 的 enabled job 并执行 (串行), 成功者 markRun.
+     * @returns 本次执行数量
+     */
+    async tick() {
+        const now = this.now();
+        const jobs = await listJobs(this.home);
+        let ran = 0;
+        for (const job of jobs) {
+            if (!job.enabled)
+                continue;
+            if (this.running.has(job.id))
+                continue; // 正在跑, 跳过防重入
+            const parsed = parseSchedule(job.schedule, now);
+            if (!parsed)
+                continue; // 解析不了的调度, 跳过 (可另做告警)
+            const lastRunAt = job.lastRunAt ? new Date(job.lastRunAt) : undefined;
+            const due = nextAfter(job.schedule, lastRunAt, now);
+            if (due && due.getTime() > now.getTime())
+                continue; // 还不到时间 (含首次: 立即触发)
+            this.running.add(job.id);
+            try {
+                await this.exec(job);
+                await markRun(job.id, now.toISOString(), this.home);
+                this.failed.delete(job.id);
+                ran += 1;
+            }
+            catch (e) {
+                this.failed.set(job.id, (this.failed.get(job.id) ?? 0) + 1);
+                console.error(`[scheduler] job 执行失败 (${job.name}):`, e?.message ?? e);
+            }
+            finally {
+                this.running.delete(job.id);
+            }
+        }
+        return ran;
+    }
+    /** 最近失败统计 (供诊断) */
+    failureCounts() {
+        return this.failed;
+    }
+}

package/dist/cron/suggestion-catalog.js

@@ -0,0 +1,41 @@
+/**
+ * suggestion-catalog.ts — 内置"下一动作"建议目录
+ *
+ * 借鉴 Hermes agent suggestion_catalog.py 心智:
+ *   - 不是让用户每次从零想"该做什么", 而是提供一组成熟、可一配置就用的自动化/策略建议
+ *   - 每个条目是 { dedupKey, title, summary, schedule?, prompt? }
+ *   - CLI `/suggestions catalog` 可列出, 用户任选自动装机 (装成 suggestion 或 cron job)
+ */
+export const SUGGESTION_CATALOG = [
+    {
+        dedupKey: 'daily-review',
+        title: '每日工作复盘',
+        summary: '每天工作结束后 5 分钟, 让 agent 总结当天做的事、遗留事项、并写进 wiki 日志。',
+        schedule: '0 18 * * *',
+        prompt: '对今天的会话做一次工作复盘: 列出完成的任务、遗留的阻塞项、并追加一行到 wiki 日志。',
+    },
+    {
+        dedupKey: 'weekly-planner',
+        title: '每周计划',
+        summary: '每周一早上生成本周重点任务清单, 纳入当前计划。',
+        schedule: '0 9 * * 1',
+        prompt: '生成本周计划: 结合最近 wiki 状态与未完成任务, 列出 3-5 条本周重点。',
+    },
+    {
+        dedupKey: 'wiki-sync',
+        title: 'Wiki 一致性检查',
+        summary: '定期跑 wiki lint / stale 检查, 发现过期页面就建议修正。',
+        schedule: '0 12 * * 5',
+        prompt: '运行一次 wiki 一致性检查 (stale_report/wiki_lint), 把发现的过期页面整理成待办建议。',
+    },
+    {
+        dedupKey: 'version-check',
+        title: '版本更新检查',
+        summary: '定期检查 bolloon 是否有新版本并提示升级。',
+        schedule: 'every 1d',
+        prompt: '检查 bolloon 是否有新版本, 若有则提示用户升级。',
+    },
+];
+export function findCatalogEntry(dedupKey) {
+    return SUGGESTION_CATALOG.find((c) => c.dedupKey === dedupKey);
+}

package/dist/cron/suggestions-command.js

@@ -0,0 +1,96 @@
+/**
+ * suggestions-command.ts — `/suggestions` CLI 子命令处理 (纯函数返回文本)
+ *
+ * 借鉴 Hermes agent suggestions_cmd.py 心智: 一个入口, 多个子动作, 全部返回可回显的文本.
+ * 用法:
+ *   /suggestions            → 列出当前待处理建议
+ *   /suggestions accept <n> → 接受第 n 条 (转成任务 / 消费)
+ *   /suggestions dismiss <n>
+ *   /suggestions clear      → 全部清空
+ *   /suggestions catalog    → 列出内置建议目录
+ *   /suggestions install <dedupKey> → 从目录装机 (生成 suggestion 或 cron job)
+ *
+ * 返回 [text, consumedSuggestionId?]; 无副作用逻辑放在 store, 本模块只做编排与文本渲染.
+ */
+import { listSuggestions, acceptSuggestion, dismissSuggestion, clearSuggestions, addSuggestion, } from './suggestions.js';
+import { addJob } from './jobs-store.js';
+import { findCatalogEntry, SUGGESTION_CATALOG } from './suggestion-catalog.js';
+function noArgs() {
+    return '用法: /suggestions \u3000| accept <n> \u3000| dismiss <n> \u3000| clear \u3000| catalog \u3000| install <dedupKey>';
+}
+function renderList(items) {
+    if (items.length === 0)
+        return '当前没有待处理建议。\n\n可用: /suggestions catalog 查看内置建议目录。';
+    const lines = items.map((s, i) => `${i + 1}. [${s.source}] ${s.summary}${s.dueAt ? ` (到期 ${s.dueAt})` : ''}`);
+    return lines.join('\n') + `\n\n用 /suggestions accept <n> 接受, dismiss <n> 忽略, clear 全清。`;
+}
+export function renderCatalog() {
+    return '内置建议目录:\n' +
+        SUGGESTION_CATALOG.map((c) => `- ${c.dedupKey}: ${c.title} — ${c.summary}`).join('\n') +
+        '\n\n用 /suggestions install <dedupKey> 装机。';
+}
+export async function handleSuggestionsCommand(args, home) {
+    const parts = args.trim().split(/\s+/).filter(Boolean);
+    const action = parts[0]?.toLowerCase() ?? '';
+    switch (action) {
+        case '':
+        case 'list': {
+            const items = await listSuggestions(home);
+            return { text: renderList(items) };
+        }
+        case 'accept': {
+            const n = Number(parts[1]);
+            if (!Number.isInteger(n) || n < 1)
+                return { text: '用法: /suggestions accept <n>' };
+            const items = await listSuggestions(home);
+            const target = items[n - 1];
+            if (!target)
+                return { text: `没有第 ${n} 条建议。` };
+            const accepted = await acceptSuggestion(target.id, home);
+            if (!accepted)
+                return { text: '该建议已被移除, 请重试。' };
+            return {
+                text: `已接受: ${accepted.summary}`,
+                accepted,
+            };
+        }
+        case 'dismiss': {
+            const n = Number(parts[1]);
+            if (!Number.isInteger(n) || n < 1)
+                return { text: '用法: /suggestions dismiss <n>' };
+            const items = await listSuggestions(home);
+            const target = items[n - 1];
+            if (!target)
+                return { text: `没有第 ${n} 条建议。` };
+            const ok = await dismissSuggestion(target.id, home);
+            return { text: ok ? `已忽略: ${target.summary}` : '忽略失败。' };
+        }
+        case 'clear': {
+            const n = await clearSuggestions(home);
+            return { text: `已清空 ${n} 条建议。` };
+        }
+        case 'catalog': {
+            return {
+                text: renderCatalog(),
+            };
+        }
+        case 'install': {
+            const key = parts[1];
+            if (!key)
+                return { text: '用法: /suggestions install <dedupKey>' };
+            const entry = findCatalogEntry(key);
+            if (!entry)
+                return { text: `目录里没有 ${key}。用 /suggestions catalog 看。` };
+            // 有 schedule + prompt → 直接生成 cron job; 否则先塞一条建议
+            const s = await addSuggestion({ dedupKey: entry.dedupKey, summary: entry.summary, source: 'system' }, home);
+            let extra = '';
+            if (entry.schedule && entry.prompt) {
+                await addJob({ name: entry.title, schedule: entry.schedule, prompt: entry.prompt }, home);
+                extra = ` 并生成了定时任务 (${entry.schedule})。`;
+            }
+            return { text: `已装机: ${entry.title}${extra}\n(可用 /suggestions dismiss 1 撤销这条建议)` };
+        }
+        default:
+            return { text: noArgs() };
+    }
+}

package/dist/cron/suggestions.js

@@ -0,0 +1,110 @@
+/**
+ * suggestions.ts — 轻量建议队列 (sticky-note suggestions)
+ *
+ * 借鉴 Hermes agent cron/suggestions.py + suggestion_catalog.py 心智:
+ *   - 建议是一个个"待办/提醒/下一动作", 由调度器/策略/系统在合适的时机塞入
+ *   - 同一 dedup_key 只保留最新的一个 (避免同一提醒重复刷屏)
+ *   - MAX_PENDING 上限, 超出自动丢最旧的 (队列有界, 不无限膨胀)
+ *   - 用户可接受 (accept) / 忽略 (dismiss) / 全部清空 (clear)
+ *   - 每个 suggestion 记住来源 (source) / 摘要 (summary) / 到期 (dueAt?, 可选)
+ *   - 落盘 ~/.bolloon/suggestions.json, 进程内互斥链序列化 (对齐 server-storage)
+ */
+import * as fs from 'fs/promises';
+import * as os from 'os';
+import * as path from 'path';
+import * as crypto from 'crypto';
+export const MAX_PENDING = 5; // 借鉴 hermes: 建议队列有界, 最长该数
+function getSuggestionsPath(home = os.homedir()) {
+    return path.join(home, '.bolloon', 'suggestions.json');
+}
+// 进程内互斥链: 所有写操作串行, 失败不毒化链 (对齐 server-storage 的 updateChannels 设计)
+let suggestionsLock = Promise.resolve();
+function withLock(fn) {
+    const run = suggestionsLock.then(fn);
+    suggestionsLock = run.then(() => undefined, () => undefined);
+    return run;
+}
+async function readAll(home) {
+    try {
+        const raw = await fs.readFile(getSuggestionsPath(home), 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (parsed?.version === 1 && Array.isArray(parsed.items))
+            return parsed;
+        return { version: 1, items: [] };
+    }
+    catch {
+        return { version: 1, items: [] };
+    }
+}
+async function writeAll(file, home) {
+    const p = getSuggestionsPath(home);
+    await fs.mkdir(path.dirname(p), { recursive: true });
+    // 原子写: 先写临时文件再 rename, 避免半截 JSON (对齐 plan-store 直接重写该校验线)
+    const tmp = p + '.tmp';
+    await fs.writeFile(tmp, JSON.stringify(file, null, 2), 'utf-8');
+    await fs.rename(tmp, p);
+}
+/**
+ * 添加一条建议. 同一 dedupKey 已存在 → 更新其 summary/来源, 并重置插入到队尾; 不超过 MAX_PENDING.
+ * @returns 新构建 (或更新后) 的 suggestion
+ */
+export async function addSuggestion(input, home = os.homedir()) {
+    return withLock(async () => {
+        const file = await readAll(home);
+        const existing = file.items.find((s) => s.dedupKey === input.dedupKey);
+        const now = new Date().toISOString();
+        const entry = {
+            id: existing?.id ?? crypto.randomUUID(),
+            dedupKey: input.dedupKey,
+            summary: input.summary,
+            source: input.source,
+            relatedTaskId: input.relatedTaskId,
+            createdAt: existing?.createdAt ?? now,
+            ...(input.dueAt ? { dueAt: input.dueAt } : {}),
+        };
+        file.items = file.items.filter((s) => s.dedupKey !== input.dedupKey);
+        file.items.push(entry);
+        while (file.items.length > MAX_PENDING)
+            file.items.shift(); // 丢最旧的
+        await writeAll(file, home);
+        return entry;
+    });
+}
+/** 全部未完成建议 */
+export async function listSuggestions(home = os.homedir()) {
+    return withLock(async () => (await readAll(home)).items);
+}
+/** 接受: 从队列移除并返回它 (调用方可据此做后续动作, 如转成 task) */
+export async function acceptSuggestion(id, home = os.homedir()) {
+    return withLock(async () => {
+        const file = await readAll(home);
+        const idx = file.items.findIndex((s) => s.id === id);
+        if (idx < 0)
+            return null;
+        const [removed] = file.items.splice(idx, 1);
+        await writeAll(file, home);
+        return removed;
+    });
+}
+/** 忽略: 从队列移除 */
+export async function dismissSuggestion(id, home = os.homedir()) {
+    return withLock(async () => {
+        const file = await readAll(home);
+        const before = file.items.length;
+        file.items = file.items.filter((s) => s.id !== id);
+        if (file.items.length === before)
+            return false;
+        await writeAll(file, home);
+        return true;
+    });
+}
+/** 全部清空 */
+export async function clearSuggestions(home = os.homedir()) {
+    return withLock(async () => {
+        const file = await readAll(home);
+        const n = file.items.length;
+        file.items = [];
+        await writeAll(file, home);
+        return n;
+    });
+}

package/dist/documents/reader.js

@@ -1,6 +1,6 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
-import pdfParse from 'pdf-parse';
+import { PDFParse } from 'pdf-parse';
 import mammoth from 'mammoth';
 export class DocumentReader {
     async read(filePath) {
@@ -55,9 +55,14 @@ export class DocumentReader {
     }
     async readPdf(filePath) {
         const dataBuffer = await fs.readFile(filePath);
-        // @ts-ignore - pdf-parse v2 API differs
-        const data = await pdfParse(dataBuffer);
-        return data.text;
+        const parser = new PDFParse({ data: dataBuffer });
+        try {
+            const result = await parser.getText();
+            return result.text;
+        }
+        finally {
+            await parser.destroy();
+        }
     }
     async readDocx(filePath) {
         const result = await mammoth.extractRawText({ path: filePath });

package/dist/index.js

@@ -635,6 +635,36 @@ async function startCLI(comm) {
         setTimeout(() => { cliOrganizeHeartbeat?.runOnce().catch(() => { }); }, 3000);
     }
     catch { /* 自动整理启动失败不阻塞 CLI */ }
+    // ==================== 2026-08-11: cron 调度心跳 (借鉴 Hermes cron/scheduler.py) ====================
+    // 轻量定时任务: 每隔一段时间扫一次 due 的 job, 把 job.prompt 投给 agent 执行.
+    // 不阻塞启动, 失败不崩溃 (各自 try/catch), 继承 organize heartbeat 的"静默降级"心智.
+    let cliCronTimer = null;
+    try {
+        const { Scheduler } = await import('./cron/scheduler.js');
+        const cronScheduler = new Scheduler({
+            now: () => new Date(),
+            exec: async (job) => {
+                // 借 agent 执行任务 prompt (脱壳为 text 提示). 无 agent / 超时 / 失败 → 抛出交给 scheduler 记录失败
+                const a = await Promise.race([
+                    await getAgent().catch(() => null),
+                    new Promise((res) => setTimeout(() => res(null), 8000)),
+                ]).catch(() => null);
+                if (!a || typeof a.promptStream !== 'function') {
+                    throw new Error('无可用 agent, 跳过调度任务');
+                }
+                await a.promptStream?.(`[cron] ${job.name}: ${job.prompt}`, () => { }, undefined, cliActiveChannelId || undefined);
+            },
+        });
+        const cronIntervalMs = Number(process.env.BOLLOON_CRON_HEARTBEAT_MS) || 60_000;
+        cliCronTimer = setInterval(() => {
+            cronScheduler.tick().catch((e) => {
+                console.error('[cron] 调度心跳失败 (不影响主流程):', e?.message ?? e);
+            });
+        }, cronIntervalMs);
+        // 启动延迟一轮, 避开启动峰值
+        setTimeout(() => { cronScheduler.tick().catch(() => { }); }, 15_000);
+    }
+    catch { /* cron 调度启动失败不阻塞 CLI */ }
     // Wait on a promise that resolves on Ctrl+C / 双击 Esc
     // (ink-app 的 requestExit 调 __inkRequestExit → resolve, 清理后 process.exit)
     let cliExitResolve = () => { };
@@ -648,6 +678,8 @@ async function startCLI(comm) {
         cliOrganizeHeartbeat?.stop();
     }
     catch { /* 非致命 */ }
+    if (cliCronTimer)
+        clearInterval(cliCronTimer);
     comm.stop();
     process.exit(0);
 }
@@ -983,6 +1015,79 @@ async function processInput(input, comm) {
         catch { /* 静默 */ }
         return;
     }
+    // /suggestions — 建议队列 (/suggestions [list|accept <n>|dismiss <n>|clear|catalog|install <key>])
+    // 借鉴 Hermes cron/suggestions.py: 有界待办建议, dedup + 用户消费
+    if (cmd === '/suggestions' || cmd.startsWith('/suggestions ')) {
+        try {
+            const { handleSuggestionsCommand } = await import('./cron/suggestions-command.js');
+            const res = await handleSuggestionsCommand(trimmed.slice('/suggestions'.length));
+            appendLine(`${C_ACCENT}◎ 建议${RESET}`);
+            appendLine(res.text);
+        }
+        catch (e) {
+            appendLine(`${C_ERROR}✗ /suggestions 失败: ${String(e.message || e).slice(0, 200)}${RESET}`);
+        }
+        return;
+    }
+    // /cron — 定时任务 (/cron list | add <name> <schedule> <prompt> | rm <id> | on/off <id>)
+    // 借鉴 Hermes cron/scheduler.py: 轻量单文件定时任务 + 调度 tick
+    if (cmd === '/cron' || cmd.startsWith('/cron ')) {
+        const { listJobs, addJob, removeJob, setEnabled } = await import('./cron/jobs-store.js');
+        const { parseSchedule } = await import('./cron/cron-parser.js');
+        const parts = trimmed.slice('/cron'.length).trim().split(/\s+/).filter(Boolean);
+        const action = parts[0]?.toLowerCase() ?? 'list';
+        try {
+            if (action === 'list') {
+                const jobs = await listJobs();
+                if (jobs.length === 0) {
+                    appendLine(`${C_ACCENT}⏱ 定时任务${RESET}${C_DIM} 空 — 用 /cron add <名称> '<schedule>' <prompt> 添加${RESET}`);
+                    appendLine(`${C_DIM}  示例: /cron add 每日复盘 '0 18 * * *' 总结今天工作并写进 wiki${RESET}`);
+                }
+                else {
+                    appendLine(`${C_ACCENT}⏱ 定时任务 (${jobs.length}):${RESET}`);
+                    for (const j of jobs) {
+                        const next = (() => { try {
+                            return parseSchedule(j.schedule)?.next.toISOString();
+                        }
+                        catch {
+                            return null;
+                        } })();
+                        appendLine(`  ${j.enabled ? C_ACCENT + '●' + RESET : C_DIM + '○' + RESET} [${C_DIM}${j.id.slice(0, 8)}${RESET}] ${j.name} ${C_DIM}· ${j.schedule}${RESET}`);
+                        appendLine(`    ${C_DIM}prompt: ${j.prompt.slice(0, 60)}${RESET}`);
+                        if (next)
+                            appendLine(`    ${C_DIM}下次: ${next} · 已跑 ${j.runCount} 次${RESET}`);
+                    }
+                }
+            }
+            else if (action === 'add') {
+                // 参数: <name> <schedule> <prompt...> — name 可能带空格, 用引号/斜杠分隔
+                const m = trimmed.slice('/cron'.length).trim().match(/^add\s+(.*?)\s+'([^']+)'?\s+(.*)$/);
+                if (!m || !parseSchedule(m[2])) {
+                    appendLine(`${C_WARN}用法: /cron add <名称> '<schedule>' <prompt>${RESET}`);
+                }
+                else {
+                    const job = await addJob({ name: m[1], schedule: m[2], prompt: m[3] }, os.homedir());
+                    appendLine(`${C_OK}✓ 已创建任务 ${job.name} (${job.schedule})${RESET}`);
+                }
+            }
+            else if (action === 'rm') {
+                const ok = await removeJob(parts[1], os.homedir());
+                appendLine(`${ok ? C_OK + '✓' + RESET + ' 已删除' : C_ERROR + '✗ 未找到' + RESET} 任务 ${parts[1] ?? ''}`);
+            }
+            else if (action === 'on' || action === 'off') {
+                const en = action === 'on';
+                const j = await setEnabled(parts[1], en, os.homedir());
+                appendLine(j ? `${C_OK}✓ ${en ? '启用' : '停用'} ${j.name}${RESET}` : `${C_ERROR}✗ 未找到 ${parts[1]}${RESET}`);
+            }
+            else {
+                appendLine(`${C_DIM}用法: /cron list | add | rm <id> | on/off <id>${RESET}`);
+            }
+        }
+        catch (e) {
+            appendLine(`${C_ERROR}✗ /cron 失败: ${String(e.message || e).slice(0, 200)}${RESET}`);
+        }
+        return;
+    }
     // /session — 当前会话信息
     if (cmd === '/session') {
         try {
@@ -1554,6 +1659,8 @@ async function processInput(input, comm) {
         appendLine(`  ${C_ACCENT}/judgement${RESET} 判断力列表`);
         appendLine(`  ${C_ACCENT}/insight${RESET} Context OS 洞察 (08-Insights)`);
         appendLine(`  ${C_ACCENT}/wiki${RESET}   wiki 状态`);
+        appendLine(`  ${C_ACCENT}/suggestions${RESET} 建议队列  ${C_DIM}list · accept <n> · dismiss <n> · clear · catalog · install${RESET}`);
+        appendLine(`  ${C_ACCENT}/cron${RESET}   定时任务  ${C_DIM}list · add <名> '<schedule>' <prompt> · rm/on/off <id>${RESET}`);
         appendLine(`  ${C_ACCENT}/dream${RESET}  随机灵感  ${C_DIM}/dream <主题> 写入梦想文档并触发循环${RESET}`);
         appendLine(`  ${C_ACCENT}@名字${RESET}     @ 命中智能体  ${C_DIM}弹出窗选择后发送给智能体${RESET}`);
         appendLine(`  ${C_ACCENT}/名字${RESET}     / 命中命令/技能/插件  ${C_DIM}输入 / 自动弹出${RESET}`);

package/dist/llm/error-lessons.js

@@ -51,3 +51,19 @@ export class ErrorLessonStore {
         this.lessons.clear();
     }
 }
+/** 分类结果 → 可执行重试计划. attempt 从 0 起, 越往后退避越大 (指数). */
+export function planRecovery(classified, attempt = 0) {
+    switch (classified.recovery) {
+        case 'backoff-retry':
+            return { shouldRetry: true, backoffMs: 1000 * (2 ** attempt), recovery: 'backoff-retry' };
+        case 'retry-once':
+            return { shouldRetry: attempt < 1, backoffMs: attempt < 1 ? 1500 : 0, recovery: 'retry-once' };
+        case 'compact-retry':
+            // 需先压缩上下文 — 重试动作交给上层 (调用方负责 autoCompact), 这里只标注
+            return { shouldRetry: false, backoffMs: 0, recovery: 'compact-retry' };
+        default:
+            return { shouldRetry: false, backoffMs: 0, recovery: classified.recovery };
+    }
+}
+/** 最大自动恢复重试次数 (Hermes 心智: 退避重试有上限, 不无限循环浪费) */
+export const MAX_RECOVERY_ATTEMPTS = 3;

package/dist/llm/pi-ai.js

@@ -103,13 +103,38 @@ export class PiAIModel {
             if (signal?.aborted || error?.name === 'AbortError') {
                 throw error; // 上层 try/catch 处理
             }
-            // 2026-08-11 (Hermes error_classifier + 会话级教训): 分类错误 + 同类只学一次
-            //   429/5xx → 退避重试; context overflow → 上层 compact 后重试; network → 重试 1 次;
-            //   auth → 不重试 (报错给用户). console 只 warn 一次新教训.
-            const { ErrorLessonStore } = await import('./error-lessons.js');
-            const lesson = (chatErrorLessons ??= new ErrorLessonStore()).learn(error);
-            if (lesson.isNewLesson) {
-                console.warn(`[llm-lesson] 新错误教训: ${lesson.classified.category} (${lesson.classified.pattern}) → ${lesson.classified.recovery}`);
+            const { ErrorLessonStore, planRecovery, MAX_RECOVERY_ATTEMPTS, classifyApiError } = await import('./error-lessons.js');
+            const store = (chatErrorLessons ??= new ErrorLessonStore());
+            const baseLesson = store.learn(error);
+            if (baseLesson.isNewLesson) {
+                console.warn(`[llm-lesson] 新错误教训: ${baseLesson.classified.category} (${baseLesson.classified.pattern}) → ${baseLesson.classified.recovery}`);
+            }
+            // 2026-08-11 (Hermes error_classifier + recovery hints): 分类后真正执行恢复动作 —
+            //   429/5xx → 退避重试; network → 重试 1 次; context overflow → 上层 compact (标注);
+            //   auth → 不重试 (报错给用户). 之前只学习教训不重试, HTTP 429/5xx 直接失败返回.
+            for (let attempt = 0; attempt < MAX_RECOVERY_ATTEMPTS; attempt++) {
+                const classified = classifyApiError(error);
+                const plan = planRecovery(classified, attempt);
+                if (!plan.shouldRetry)
+                    break; // 不可恢复 / 已到 retry-once 上限
+                const backoffMs = plan.backoffMs;
+                console.warn(`[llm-recovery] ${classified.category} attempt ${attempt + 1}/${MAX_RECOVERY_ATTEMPTS}, 退避 ${backoffMs}ms 重试`);
+                await new Promise((r) => setTimeout(r, backoffMs));
+                try {
+                    const response = await this.generateText({
+                        messages,
+                        temperature: 0.8,
+                        maxTokens: 16384,
+                        signal,
+                        tools,
+                    });
+                    return { reply: response.reply, toolCalls: response.toolCalls };
+                }
+                catch (retryErr) {
+                    if (signal?.aborted || retryErr?.name === 'AbortError')
+                        throw retryErr;
+                    error = retryErr; // 记录最后一次错误, 循环继续重试 (backoff 递增)
+                }
             }
             console.error('PiAI chat error:', error);
             // 2026-06-15: 真实 error 信息 + 明确告诉 LLM "这是 API 错, 不要 retry"

package/dist/web/client.js

@@ -10,8 +10,13 @@
     if (typeof require !== "undefined") return require.apply(this, arguments);
     throw Error('Dynamic require of "' + x + '" is not supported');
   });
-  var __esm = (fn, res) => function __init() {
-    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  var __esm = (fn, res, err) => function __init() {
+    if (err) throw err[0];
+    try {
+      return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+    } catch (e) {
+      throw err = [e], e;
+    }
   };
   var __export = (target, all) => {
     for (var name in all)
@@ -379,10 +384,11 @@
     if (!content) return null;
     const strippedContent = content.replace(/<think[\s\S]*?<\/think/g, "");
     try {
-      const result = /* @__PURE__ */ function _diagProbe() {
+      const result = /* @__PURE__ */ (function _diagProbe() {
         return null;
-      }();
-      const probe = function _doParse() {
+      })();
+      void result;
+      const probe = (function _doParse() {
         const m1 = strippedContent.match(/<invoke\s+name=["']([\w]+)["']/);
         if (m1) {
           return { name: m1[1], args: { __probe_invoketag: "1" } };
@@ -396,7 +402,7 @@
           return { name: m3[1], args: { __probe_json_name: "1" } };
         }
         return null;
-      }();
+      })();
       console.warn(
         "[parseToolCall diag] rawLen=" + content.length + " strippedLen=" + strippedContent.length + " probeName=" + (probe?.name ?? "null") + " rawHead=" + JSON.stringify(content.slice(0, 500))
       );
@@ -1609,22 +1615,22 @@
   var lastSeenMsgIds = /* @__PURE__ */ new Map();
   var COLLAPSED_PEERS_KEY = "bolloon.p2p.collapsedPeers";
   var SEEN_PEERS_KEY = "bolloon.p2p.seenPeers";
-  var collapsedPeers = function loadCollapsed() {
+  var collapsedPeers = (function loadCollapsed() {
     try {
       const raw = localStorage.getItem(COLLAPSED_PEERS_KEY);
       return new Set(raw ? JSON.parse(raw) : []);
     } catch {
       return /* @__PURE__ */ new Set();
     }
-  }();
-  var seenPeers = function loadSeen() {
+  })();
+  var seenPeers = (function loadSeen() {
     try {
       const raw = localStorage.getItem(SEEN_PEERS_KEY);
       return new Set(raw ? JSON.parse(raw) : []);
     } catch {
       return /* @__PURE__ */ new Set();
     }
-  }();
+  })();
   function saveCollapsedPeers() {
     try {
       localStorage.setItem(COLLAPSED_PEERS_KEY, JSON.stringify([...collapsedPeers]));
@@ -5845,7 +5851,7 @@ ${m.content}`, "user", false, log);
   }
   var p2pToggleAllBtn = document.getElementById("p2p-toggle-all-btn");
   if (p2pToggleAllBtn) {
-    let syncToggleAllBtn = function() {
+    let syncToggleAllBtn2 = function() {
       const allPks = /* @__PURE__ */ new Set([
         ...knownPeers.map((p) => p.publicKey),
         ...remoteChannels.map((g) => g.peerId)
@@ -5866,7 +5872,7 @@ ${m.content}`, "user", false, log);
         p2pToggleAllBtn.title = "\u70B9\u51FB\u6298\u53E0\u6240\u6709 P2P \u597D\u53CB";
       }
     };
-    syncToggleAllBtn2 = syncToggleAllBtn;
+    syncToggleAllBtn = syncToggleAllBtn2;
     p2pToggleAllBtn.addEventListener("click", (e) => {
       e.stopPropagation();
       const allPks = /* @__PURE__ */ new Set([
@@ -5882,12 +5888,12 @@ ${m.content}`, "user", false, log);
       } else {
         collapseAllPeers();
       }
-      syncToggleAllBtn();
+      syncToggleAllBtn2();
     });
-    window.__syncP2PToggleAllBtn = syncToggleAllBtn;
-    syncToggleAllBtn();
+    window.__syncP2PToggleAllBtn = syncToggleAllBtn2;
+    syncToggleAllBtn2();
   }
-  var syncToggleAllBtn2;
+  var syncToggleAllBtn;
   var refreshSharedBtn = document.getElementById("refresh-shared-btn");
   if (refreshSharedBtn) {
     refreshSharedBtn.addEventListener("click", async (e) => {

package/dist/web/loop-noise.js

@@ -0,0 +1,86 @@
+/**
+ * loop-noise.ts — 良性连接拆除噪音抑制 (借鉴 Hermes tui_gateway/loop_noise.py)
+ *
+ * Hermes 问题: Desktop 客户端强关 WebSocket 时, gateway 还有 pending socket 操作,
+ *   asyncio transport teardown 对每个 _call_connection_lost 回调打一条完整 traceback,
+ *   单次断开可刷 50+ 条相同 ConnectionResetError/WinError 10054 进 errors.log (#50005).
+ *
+ * Bolloon 等价: SSE/HTTP 客户端断开后, 服务端向已关闭的 res 写消息 → 每次广播抛
+ *   "write EPIPE / write after end / 连接被重置"。这不是可行动的错误 — 是对端在
+ *   写 drain 前挂线的预期副作用。这里对"拆除期写失败"这类良性错误做一次过滤,
+ *   把同类错误折叠成一行 debug, 其余错误原样交给默认逻辑, 真实的循环 bug 仍会暴露。
+ *
+ * 设计要点 (对齐 hermes):
+ *   - 同时看错误类型 AND 写路径标记 (broadcast 的 res.write) 才吞 — 其它地方抛同样错误
+ *     不被误吞 (对应 hermes 的 _call_connection_lost gating)。
+ *   - 同类错误窗口节流 (channel_directory 模式): 同一 (类别, 摘要) 窗口内只 warn 一次,
+ *     复用 delivery-ledger 已有的 shouldWarn 心智。
+ */
+/** 良性拆除期写失败: 对端挂线 / 写已结束的流。等价 hermes 的 ConnectionReset/Aborted/BrokenPipe。 */
+const BENIGN_WRITE_PATTERNS = [
+    /write EPIPE/i,
+    /write after end/i,
+    /ECONNRESET|connection (reset|aborted)|10054|10053/i,
+    /Cannot (write|set headers) after (the client|they) (are |is |has )?(closed|ended)/i,
+    /socket hang up/i,
+    /broken pipe/i,
+];
+/**
+ * 一条错误是否属于"写给已断开客户端"的良性噪音。
+ * 双重判定等价 hermes 的 (错误类型 + _call_connection_lost 回调 gating):
+ *   - 类型/消息命中拆除类写失败 (ConnectionReset/BrokenPipe/写已结束)
+ *   - 且调用点本来就是"写路径" — 由 guardClientWriteNoise 只在 res.write 处调用保证
+ */
+export function isBenignClientWriteNoise(err) {
+    const msg = String(err?.message || err || '');
+    return BENIGN_WRITE_PATTERNS.some((re) => re.test(msg));
+}
+/** 同类错误节流器: 同 (类别, 摘要) 窗口内返回 false (不重复 warn), 窗口外返回 true 并刷新。 */
+export class NoiseThrottle {
+    windowMs;
+    last = new Map();
+    constructor(windowMs = 5 * 60 * 1000) {
+        this.windowMs = windowMs;
+    }
+    shouldWarn(category, detail) {
+        const key = `${category}|${detail.slice(0, 80)}`;
+        const now = Date.now();
+        const last = this.last.get(key) ?? 0;
+        if (now - last < this.windowMs)
+            return false;
+        this.last.set(key, now);
+        return true;
+    }
+    reset() {
+        this.last.clear();
+    }
+}
+/**
+ * 包装一个"可能抛拆除期写失败"的写操作:
+ *   - 良性噪音 → 静默吞一次 (不抛出, 不打印), 仅按节流器偶尔 debug 一行
+ *   - 其它错误 → 原样抛出 / 转交 onError, 不掩盖真实问题
+ *
+ * @param fn 实际写操作 (抛异常或 reject)
+ * @param opts 诊断标签 + 可选节流器 (默认全局单例) + 可选 onError 回调 (捕获真实错误)
+ */
+export async function guardClientWriteNoise(fn, opts = { label: 'write' }) {
+    const throttle = opts.throttle ?? globalNoiseThrottle;
+    try {
+        await fn();
+    }
+    catch (e) {
+        if (isBenignClientWriteNoise(e)) {
+            // 良性: 折叠成一行 (节流), 不抛出
+            if (throttle.shouldWarn(opts.label, String(e?.message || e))) {
+                console.debug(`[loop-noise] 已抑制良性客户端断开写失败 (${opts.label}): ${String(e?.message || '').slice(0, 120)}`);
+            }
+            return;
+        }
+        if (opts.onError)
+            opts.onError(e);
+        else
+            throw e;
+    }
+}
+/** 全局默认节流器 (server 生命期复用, 跨连接共享告警窗口)。 */
+export const globalNoiseThrottle = new NoiseThrottle();

package/dist/web/server-sse.js

@@ -11,6 +11,7 @@
  * SSEClient type 来自 ./server-types.ts.
  */
 import * as crypto from 'crypto';
+import { guardClientWriteNoise } from './loop-noise.js';
 const sseClients = new Set();
 export function getSseClients() {
     return sseClients;
@@ -57,12 +58,16 @@ export function broadcast(data, channelId) {
     console.log(`[broadcast] type=${data.type}, channelId=${channelId}, seq=${seq}, msgId=${msgId}, clients=${sseClients.size}`);
     for (const client of sseClients) {
         if (!channelId || client.channelId === channelId) {
-            try {
+            // 2026-08-11 (Hermes loop_noise): 客户端在写 drain 前断开 → 每次广播对已关闭 res
+            //   write 都会抛 "write EPIPE / write after end / 连接已关闭"。这是预期副作用, 不是
+            //   bug — guardClientWriteNoise 把同类错误折叠成一行 (节流), 不打印每条刷屏。
+            void guardClientWriteNoise(() => {
                 client.res.write(message);
-            }
-            catch (e) {
-                console.error(`[broadcast] 写入失败:`, e.message);
-            }
+                return Promise.resolve();
+            }, {
+                label: `sse-broadcast:${data.type}`,
+                onError: (e) => console.error(`[broadcast] 写入失败 (非良性): ${e.message}`),
+            });
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
-{
+{
   "name": "@bolloon/bolloon-agent",
-  "version": "0.4.0",
+  "version": "0.4.3",
   "type": "module",
   "description": "P2P AI Document Agent - 全局安装后执行 `bolloon` 启动产品",
   "main": "dist/cli-entry.js",
@@ -55,11 +55,10 @@
     "src/constraint-runtime"
   ],
   "dependencies": {
-    "@bolloon/bolloon-agent": "^0.3.22",
     "@bolloon/constraint-runtime": "0.1.0",
-    "@capacitor/android": "^8.4.1",
-    "@capacitor/core": "^8.4.1",
-    "@capacitor/ios": "^8.4.2",
+    "@capacitor/android": "^8.5.0",
+    "@capacitor/core": "^8.5.0",
+    "@capacitor/ios": "^8.5.0",
     "@chainsafe/libp2p-noise": "^17.0.0",
     "@chainsafe/libp2p-yamux": "^8.0.1",
     "@diap/sdk": "^0.2.4",
@@ -72,57 +71,57 @@
     "@libp2p/tcp": "^11.0.20",
     "@libp2p/upnp-nat": "^4.0.20",
     "@multiformats/multiaddr": "^13.0.3",
-    "@noble/hashes": "^1.3.0",
+    "@noble/hashes": "^2.3.0",
     "@orbitdb/core": "^4.0.0",
-    "@polymarket/client": "^0.2.0",
+    "@polymarket/client": "^0.5.0",
     "@rayhanadev/iroh": "^0.1.1",
-    "@x402/aptos": "^2.20.0",
-    "@x402/avm": "^2.20.0",
-    "@x402/axios": "^2.20.0",
-    "@x402/core": "^2.20.0",
-    "@x402/evm": "^2.20.0",
-    "@x402/express": "^2.20.0",
-    "@x402/extensions": "^2.20.0",
-    "@x402/fastify": "^2.20.0",
-    "@x402/fetch": "^2.20.0",
-    "@x402/hedera": "^2.20.0",
-    "@x402/hono": "^2.20.0",
-    "@x402/keeta": "^2.20.0",
-    "@x402/mcp": "^2.20.0",
-    "@x402/next": "^2.20.0",
-    "@x402/paywall": "^2.20.0",
-    "@x402/stellar": "^2.20.0",
-    "@x402/svm": "^2.20.0",
-    "@x402/tvm": "^2.20.0",
+    "@x402/aptos": "^2.21.0",
+    "@x402/avm": "^2.21.0",
+    "@x402/axios": "^2.21.0",
+    "@x402/core": "^2.21.0",
+    "@x402/evm": "^2.21.0",
+    "@x402/express": "^2.21.0",
+    "@x402/extensions": "^2.21.0",
+    "@x402/fastify": "^2.21.0",
+    "@x402/fetch": "^2.21.0",
+    "@x402/hedera": "^2.21.0",
+    "@x402/hono": "^2.21.0",
+    "@x402/keeta": "^2.21.0",
+    "@x402/mcp": "^2.21.0",
+    "@x402/next": "^2.21.0",
+    "@x402/paywall": "^2.21.0",
+    "@x402/stellar": "^2.21.0",
+    "@x402/svm": "^2.21.0",
+    "@x402/tvm": "^2.21.0",
     "b4a": "^1.8.1",
     "dotenv": "^17.4.2",
-    "esbuild": "^0.24.0",
     "express": "^5.2.1",
     "helia": "^7.1.3",
     "ink": "^7.1.1",
     "ink-text-input": "^6.0.0",
-    "libp2p": "^3.3.0",
-    "mammoth": "^1.6.0",
-    "pdf-parse": "^1.1.4",
+    "libp2p": "^3.3.8",
+    "mammoth": "^1.12.1",
+    "pdf-parse": "^2.4.5",
     "platform": "^1.3.6",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
-    "viem": "^2.52.0"
+    "viem": "^2.55.13"
   },
   "devDependencies": {
-    "@capacitor/cli": "^8.4.1",
-    "@playwright/test": "^1.60.0",
+    "@capacitor/cli": "^8.5.0",
+    "@playwright/test": "^1.62.1",
     "@types/express": "^5.0.6",
     "@types/node": "^25.9.1",
     "@types/pdf-parse": "^1.1.5",
     "@types/react": "^19.2.18",
     "@types/react-dom": "^19.2.4",
-    "concurrently": "^9.2.1",
-    "electron": "^42.3.0",
-    "electron-builder": "^26.15.5",
+    "concurrently": "^10.0.4",
+    "electron": "^43.3.0",
+    "electron-builder": "^26.15.7",
+    "esbuild": "^0.28.2",
     "lefthook": "^2.1.9",
-    "playwright": "^1.60.0",
-    "tsx": "^4.0.0",
+    "playwright": "^1.62.1",
+    "tsx": "^4.23.12",
     "typescript": "^5.0.0",
     "vitest": "^4.1.6"
   },