@bolloon/bolloon-agent 0.4.23 → 0.4.25

package/dist/web/server.js

@@ -1530,6 +1530,11 @@ async function getAgentForChannel(channelId, channelDid, channelName, channelDid
         usePivotLoop: true,
     }, true); // forceNew: true 强制创建新实例
     channelSessions.set(sessionKey, session);
+    // 2026-09-16: 标记运行表面 — 落盘 run 记录里能区分 web 运行 (CLI 默认 cli)
+    try {
+        session.setRunSurface?.('web');
+    }
+    catch { /* 老 session 无此方法则忽略 */ }
     if (channelDid) {
         console.log(`[Agent] 新建频道 ${channelId} session, DID = ${channelDid}, sessionId = ${currentSessionId}`);
     }
@@ -1626,6 +1631,92 @@ export async function createWebServer(port = 3000, options = {}) {
     catch (err) {
         console.warn('[createWebServer] bootstrap 失败 (非致命):', err);
     }
+    // 2026-09-16: 孤儿运行对账 — 上次进程留下的 running 记录改判 interrupted。
+    // 不做这步的话, 刷新/重启后 UI 会显示"还在跑"的幽灵运行 (最典型的假状态)。
+    try {
+        const { reconcileOrphans } = await import('../agents/run-store.js');
+        const rec = await reconcileOrphans();
+        if (rec.interrupted.length) {
+            console.log(`[runs] 对账: ${rec.interrupted.length} 条上次中断的运行已标 interrupted (${rec.interrupted.slice(0, 3).join(', ')}${rec.interrupted.length > 3 ? '…' : ''})`);
+        }
+        if (rec.stillRunning.length)
+            console.log(`[runs] 存活运行: ${rec.stillRunning.length} 条`);
+    }
+    catch (err) {
+        console.warn('[runs] 对账失败 (非致命):', err?.message);
+    }
+    // 2026-09-16 (M2-B): ExecutionSupervisor —— 长期执行层。
+    //   页面关掉、进程重启后由它把 Goal 继续下去; 跨进程排他靠 Goal lease (不是内存状态)。
+    //   Harness 管"这一段能不能安全执行", Supervisor 管"这个目标还要不要继续执行"。
+    if (process.env.BOLLOON_SUPERVISOR !== '0') {
+        try {
+            const { getSupervisor } = await import('../agents/execution-supervisor.js');
+            const { runSupervisorHost } = await import('../agents/supervisor-host.js');
+            const tickMs = Number(process.env.BOLLOON_SUPERVISOR_TICK_MS) || 30_000;
+            const leaseMs = Number(process.env.BOLLOON_SUPERVISOR_LEASE_MS) || 90_000;
+            // 执行器**在每次执行前解析** (不写死): web 宿主按 Goal 的 channelId 找 channel agent。
+            // 解析不出来 → 只诊断不执行, 且不写任何 Goal 状态。
+            const resolver = async (req) => {
+                const goal = req.goal;
+                if (!goal?.channelId) {
+                    return { ok: false, kind: 'none', reason: 'Goal 没有 channelId: 无法在 web 进程内解析执行器' };
+                }
+                const agent = await getAgentForChannel(goal.channelId, goal.agentId || '', undefined, undefined);
+                if (!agent)
+                    return { ok: false, kind: 'none', reason: 'channel agent 不可用' };
+                const runner = async (r) => {
+                    if (r.kind === 'resume' && r.prevRunId && typeof agent.resumeRun === 'function') {
+                        const res = await agent.resumeRun(r.prevRunId);
+                        return { runId: r.prevRunId, status: res?.ok ? 'done' : 'failed', error: res?.ok ? undefined : res?.reason };
+                    }
+                    // 跨预算继续: 新 Run 必须挂在同一个 Goal 下 (setGoalId), 并带上上一个 Run 的非幂等守卫
+                    agent.setGoalId?.(goal.goalId);
+                    agent.setContinuationGuards?.(r.guards || []);
+                    const reply = await agent.prompt(r.instruction);
+                    // 注意: prompt 收尾会清空 currentRunId → 必须读 lastRunId (否则会拿上一条 run 做决策)
+                    const runId = agent.getLastRunId?.() || agent.getRunId?.();
+                    return { runId, status: 'done', reply: typeof reply === 'string' ? reply.slice(0, 500) : undefined };
+                };
+                return { ok: true, runner, kind: 'web' };
+            };
+            const sup = getSupervisor({
+                tickIntervalMs: tickMs,
+                leaseTtlMs: leaseMs,
+                maxPerTick: Number(process.env.BOLLOON_SUPERVISOR_MAX_PER_TICK) || 1,
+                log: (m) => console.log(m),
+                onEvent: (e) => { try {
+                    broadcast({ type: 'supervisor', ...e });
+                }
+                catch { /* UI 广播失败不影响调度 */ } },
+                resolver: resolver,
+            });
+            // 宿主层: 跨进程单 tick 互斥 + 宿主身份/心跳落盘 + 优雅停止
+            const host = await runSupervisorHost({
+                supervisor: sup,
+                tickIntervalMs: tickMs,
+                leaseTtlMs: leaseMs,
+                runnerKind: 'web',
+                log: (m) => console.log(m),
+            });
+            global.__bolloonSupervisorHost = host;
+            console.log(`[supervisor] 长期执行层已启动 (owner=${host.state.owner}, worker=${host.state.workerId}, tick=${tickMs}ms, lease=${leaseMs}ms)`);
+            const stopHost = (sig) => { void host.stop(`signal:${sig}`).finally(() => process.exit(0)); };
+            process.once('SIGINT', () => stopHost('SIGINT'));
+            process.once('SIGTERM', () => stopHost('SIGTERM'));
+        }
+        catch (err) {
+            // 启动失败必须可观测 (不许静默降级成长时间不执行)
+            const msg = `[supervisor] 启动失败: ${err?.message || err}`;
+            console.error(msg);
+            try {
+                broadcast({ type: 'supervisor', kind: 'startup_failed', message: msg });
+            }
+            catch { /* ignore */ }
+        }
+    }
+    else {
+        console.log('[supervisor] 长期执行层已关闭 (BOLLOON_SUPERVISOR=0)');
+    }
     // 2026-08-03 (Context OS P5): 初始化资产层 12+3 目录 (幂等, 每层 README 声明职责边界)
     try {
         const { ensureContextOsDirs } = await import('../bootstrap/context-os.js');
@@ -2439,6 +2530,19 @@ export async function createWebServer(port = 3000, options = {}) {
                     console.log(`[cron] 调度器已启动 (每 ${Math.round((Number(process.env.BOLLOON_CRON_HEARTBEAT_MS) || 60_000) / 1000)}s 一轮, tick 带锁 + DND)`);
                 // 暴露给 /message 使用 (主任务闸门)
                 global.__bolloonMainTask = { enterMainTask, exitMainTask };
+                // 2026-09-16: 运行失速巡检 (每 60s) — running 但长时间没新进展的运行标 stalled,
+                //   让 UI/CLI 能说"这个运行卡住了", 而不是永远转圈 (crash 由启动时对账兜底)。
+                setInterval(() => {
+                    void (async () => {
+                        try {
+                            const { superviseRuns } = await import('../agents/run-store.js');
+                            const r = await superviseRuns();
+                            if (r.stalled.length)
+                                console.warn(`[runs] 失速巡检: ${r.stalled.length} 条运行标 stalled (${r.stalled.slice(0, 3).join(', ')})`);
+                        }
+                        catch { /* 巡检失败不影响主流程 */ }
+                    })();
+                }, 60_000);
             }
             catch (cronErr) {
                 console.warn('[cron] 调度器启动失败 (non-fatal):', cronErr?.message);
@@ -2832,6 +2936,288 @@ ${goalDesc}
             res.status(400).json({ ok: false, severity: 'block', reason: e?.message ?? 'parse error' });
         }
     });
+    // 2026-09-16: 运行记录 (持久化 harness) — 当前 + 历史 agent 运行。跨重载可读。
+    // 2026-09-16 (2-G.1): Skills Manager —— 与 CLI `/skills` `/skill` 读同一份事实 (skills-registry.json + 技能目录)
+    app.get('/api/skills', async (_req, res) => {
+        try {
+            const { getSkillsManager } = await import('../agents/skills-manager.js');
+            const sm = getSkillsManager();
+            const skills = await sm.view();
+            res.json({ count: skills.length, registryPath: (await import('../agents/skills-manager.js')).registryPath(), skills, health: await sm.health() });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
+        }
+    });
+    app.get('/api/skills/health', async (_req, res) => {
+        try {
+            const { getSkillsManager } = await import('../agents/skills-manager.js');
+            res.json(await getSkillsManager().health());
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
+        }
+    });
+    app.get('/api/skills/:name', async (req, res) => {
+        try {
+            const { getSkillsManager } = await import('../agents/skills-manager.js');
+            const s = await getSkillsManager().inspect(String(req.params.name));
+            if (!s) {
+                res.status(404).json({ error: `没有这个技能: ${req.params.name}` });
+                return;
+            }
+            res.json({ skill: s });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
+        }
+    });
+    app.post('/api/skills/import', async (req, res) => {
+        try {
+            const ref = String(req.body?.ref || '').trim();
+            if (!ref) {
+                res.status(400).json({ error: '要 body {ref: "bolloon://skill/<cid>" | "ipfs://<cid>" | "<cid>"}' });
+                return;
+            }
+            const { getSkillsManager } = await import('../agents/skills-manager.js');
+            const r = await getSkillsManager().import(ref, { force: !!req.body?.force });
+            if (!r.ok) {
+                res.status(409).json({ error: r.error });
+                return;
+            }
+            res.json({ ok: true, name: r.name, version: r.version, skill: r.skill });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
+        }
+    });
+    // enable / disable / approve / validate / quarantine (Express 5 不支持内联正则, 显式写开)
+    for (const action of ['enable', 'disable', 'approve', 'validate', 'quarantine']) {
+        app.post(`/api/skills/:name/${action}`, async (req, res) => {
+            try {
+                const { getSkillsManager } = await import('../agents/skills-manager.js');
+                const sm = getSkillsManager();
+                const name = String(req.params.name);
+                const r = action === 'approve' ? await sm.approve(name, 'web')
+                    : action === 'quarantine' ? await sm.quarantine(name, String(req.body?.reason || 'web 手动隔离'))
+                        : action === 'enable' ? await sm.enable(name)
+                            : action === 'disable' ? await sm.disable(name)
+                                : await sm.validate(name);
+                if (!r.ok && !r.skill) {
+                    res.status(409).json({ error: r.reason || r.issues || '操作未完成' });
+                    return;
+                }
+                res.json({ ok: r.ok, name, action, skill: r.skill, issues: r.issues });
+            }
+            catch (err) {
+                res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
+            }
+        });
+    }
+    // 2026-09-16 (M2-B): 长期执行层诊断 + 手动推进 —— 与 CLI /supervise 读同一份持久化记录
+    app.get('/api/supervisor', async (_req, res) => {
+        try {
+            const { getSupervisor } = await import('../agents/execution-supervisor.js');
+            const { readSupervisorState, supervisorStatePath } = await import('../agents/supervisor-host.js');
+            const { wakeReport, listRunnableGoals } = await import('../agents/goal-store.js');
+            const { runnable, skipped } = await listRunnableGoals({ now: Date.now() });
+            res.json({
+                supervisor: getSupervisor().status(),
+                /** 宿主身份/心跳 (谁在跑、跑到哪、上次有没有好好停) */
+                host: await readSupervisorState(),
+                hostStatePath: supervisorStatePath(),
+                wake: await wakeReport(),
+                runnable: runnable.map((g) => ({ goalId: g.goalId, objective: g.objective, status: g.status })),
+                skipped,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
+        }
+    });
+    // 手动踢一个调度周期 (调试/验收用; 不改变任何"事实来源")
+    app.post('/api/supervisor/tick', async (_req, res) => {
+        try {
+            const { getSupervisor } = await import('../agents/execution-supervisor.js');
+            const report = await getSupervisor().tickOnce();
+            res.json({ ok: true, report });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
+        }
+    });
+    // 2026-09-16 (2-E 第 4 类): 外部事件到达 → 唤醒在等它的 Goal (不重发已成功的请求)
+    app.post('/api/goals/:goalId/wake', async (req, res) => {
+        const goalId = String(req.params.goalId);
+        try {
+            const { getSupervisor } = await import('../agents/execution-supervisor.js');
+            const { readGoal, setContinuation } = await import('../agents/goal-store.js');
+            const g = await readGoal(goalId);
+            if (!g) {
+                res.status(404).json({ error: `goal 不存在: ${goalId}` });
+                return;
+            }
+            const woke = await getSupervisor().notifyExternal(goalId);
+            if (!woke) {
+                // 没在等外部事件也要如实回答 (可能它其实在等人/在跑), 但允许显式加急
+                if (req.body?.force) {
+                    await setContinuation(goalId, { wakeReason: 'active', autoContinue: true, wakeAt: undefined, needsExternal: undefined });
+                    res.json({ ok: true, goalId, woke: false, forced: true, note: `原状态 ${g.status} (不在等外部事件), 已按 force 加急` });
+                    return;
+                }
+                res.status(409).json({ error: `Goal 不在等外部事件 (status=${g.status}, wakeReason=${g.continuation?.wakeReason || '无'})`, force_hint: '加 body {"force":true} 可强制加急' });
+                return;
+            }
+            res.json({ ok: true, goalId, woke: true, note: '已唤醒: 下一次 Supervisor tick 会推进它' });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
+        }
+    });
+    // 2026-09-16 (M5): 运行列表 —— Web 与 CLI 读同一份 run 事实 (~/.bolloon/runs)
+    app.get('/api/runs', async (req, res) => {
+        try {
+            const { listRuns, formatRunLine } = await import('../agents/run-store.js');
+            const status = String(req.query?.status || '').trim();
+            const limit = Number(req.query?.limit || 20);
+            const runs = await listRuns({ status: status ? status : undefined, limit });
+            res.json({
+                count: runs.length,
+                runs,
+                lines: runs.map(formatRunLine),
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
+        }
+    });
+    // 2026-09-16 (M5): 单个 run + 停止原因/checkpoint/最近步骤/recovery/harness 事件 (两端同一份事实)
+    app.get('/api/runs/:runId', async (req, res) => {
+        try {
+            const { readRun } = await import('../agents/run-store.js');
+            const run = await readRun(String(req.params.runId));
+            if (!run) {
+                res.status(404).json({ error: `run 不存在: ${req.params.runId}` });
+                return;
+            }
+            const goal = run.goalId ? await (await import('../agents/goal-store.js')).readGoal(run.goalId) : null;
+            res.json({ run, goal, checkpoint: run.checkpoint, steps: run.steps, recovery: run.recovery, harness: run.harness || [] });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
+        }
+    });
+    // 2026-09-16 (M5): 继续 interrupted/stalled/paused/needs_human/awaiting_external 的运行 —— 真从 checkpoint 继续
+    app.post('/api/runs/:runId/resume', async (req, res) => {
+        const runId = String(req.params.runId);
+        try {
+            const { readRun, RESUMABLE_STATUSES } = await import('../agents/run-store.js');
+            const run = await readRun(runId);
+            if (!run) {
+                res.status(404).json({ error: `run 不存在: ${runId}` });
+                return;
+            }
+            // 先做只读校验: 不可恢复的状态明确拒绝 (不假装"已开始"), 避免前端以为在跑
+            if (!RESUMABLE_STATUSES.includes(run.status)) {
+                res.status(409).json({ error: `状态 ${run.status} 不可恢复 (可恢复: ${RESUMABLE_STATUSES.join('/')})` });
+                return;
+            }
+            if (!run.channelId) {
+                res.status(400).json({ error: '该 run 没有 channelId, 无法在 web 端恢复 (请在 CLI 用 /resume)' });
+                return;
+            }
+            const agent = await getAgentForChannel(run.channelId);
+            if (!agent?.resumeRun) {
+                res.status(409).json({ error: '该 channel 的 agent 不支持 resumeRun' });
+                return;
+            }
+            // 异步执行: resume 可能跑几分钟; 状态从 /api/runs/:runId 读 (recovering → running → done/failed)
+            void agent.resumeRun(runId).then((r) => {
+                if (!r?.ok)
+                    console.warn(`[runs] resume ${runId} 失败:`, r?.reason);
+            }).catch((err) => console.warn(`[runs] resume ${runId} 异常:`, err?.message));
+            res.json({ ok: true, accepted: true, runId, note: '已开始恢复; 状态请读 GET /api/runs/:runId' });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
+        }
+    });
+    // 2026-09-16 (M5): 人工批准 —— needs_human 的运行经人确认后继续 (= 带批准的 resume)
+    app.post('/api/runs/:runId/approve', async (req, res) => {
+        const runId = String(req.params.runId);
+        try {
+            const { readRun, recordRecovery } = await import('../agents/run-store.js');
+            const run = await readRun(runId);
+            if (!run) {
+                res.status(404).json({ error: `run 不存在: ${runId}` });
+                return;
+            }
+            if (run.status !== 'needs_human') {
+                res.status(409).json({ error: `只有 needs_human 的运行需要批准 (当前 ${run.status})` });
+                return;
+            }
+            await recordRecovery(runId, { errorClass: run.errorClass || 'unknown', message: '人工批准后继续', action: 'resume' });
+            if (!run.channelId) {
+                res.status(400).json({ error: '该 run 没有 channelId, 请在 CLI 用 /approve' });
+                return;
+            }
+            const agent = await getAgentForChannel(run.channelId, run.channelId, run.agentId, {});
+            if (!agent?.resumeRun) {
+                res.status(409).json({ error: '该 channel 的 agent 不支持 resumeRun' });
+                return;
+            }
+            void agent.resumeRun(runId).catch((err) => console.warn(`[runs] approve ${runId} 异常:`, err?.message));
+            res.json({ ok: true, accepted: true, runId, approved: true });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
+        }
+    });
+    // 2026-09-16 (M5): 暂停 / 中止 —— 只改 run 状态; 运行中的 agent 会在下一次循环检查时如实停下
+    //   (Express 5 的 path-to-regexp 不再支持 `:action(a|b)` 内联正则, 所以两条写开)
+    for (const [suffix, to] of [['pause', 'paused'], ['abort', 'aborted']]) {
+        app.post(`/api/runs/:runId/${suffix}`, async (req, res) => {
+            const runId = String(req.params.runId);
+            try {
+                const { setRunStatus } = await import('../agents/run-store.js');
+                const r = await setRunStatus(runId, to, { error: `外部请求 (${suffix})` });
+                if (!r.ok) {
+                    res.status(409).json({ error: r.reason || '状态迁移被拒绝' });
+                    return;
+                }
+                res.json({ ok: true, runId, status: to, note: '运行中的 agent 会在下一轮循环检查时停下 (轮内不打断)' });
+            }
+            catch (err) {
+                res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
+            }
+        });
+    }
+    // 2026-09-16 (M2): 目标 (Goal) —— 目标事实来源; runId → goalId → objective/successCriteria 反查链
+    app.get('/api/goals', async (req, res) => {
+        try {
+            const { listGoals, formatGoalLine } = await import('../agents/goal-store.js');
+            const status = String(req.query?.status || '').trim();
+            const goals = await listGoals({ status: status ? status : undefined, limit: Number(req.query?.limit || 30) });
+            res.json({ count: goals.length, goals, lines: goals.map(formatGoalLine) });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
+        }
+    });
+    app.get('/api/goals/:goalId', async (req, res) => {
+        try {
+            const { readGoal, evaluateGoalCompletion } = await import('../agents/goal-store.js');
+            const goal = await readGoal(String(req.params.goalId));
+            if (!goal) {
+                res.status(404).json({ error: `goal 不存在: ${req.params.goalId}` });
+                return;
+            }
+            res.json({ goal, completion: evaluateGoalCompletion(goal) });
+        }
+        catch (err) {
+            res.status(500).json({ error: String(err?.message || err).slice(0, 200) });
+        }
+    });
     // 2026-08-13 (Phase E1): Agent 服务 Registry — 发现层 (OrbitDB 去中心化 + 本地 fallback)
     app.get('/api/registry', async (_req, res) => {
         try {
@@ -3020,14 +3406,61 @@ ${goalDesc}
     // 2026-09-15: agent-delegate (manifest 协议 + agent_delegate) **启动即挂载**
     //   文档 bolloon-gateway-join.md 第 3 节要求 POST /api/agent/register 可用;
     //   之前只在 iroh 懒初始化 (/api/iroh/info 首次访问) 的收尾挂上 → 没触发时恒 404。
+    //
+    //   2026-09-15 (二修): 同时注入**真执行器** —— 被委派的一方不再是
+    //   `resultCid: mock-<ts>` 的假签收: 真的跑本地 agent session 出结果,
+    //   并把结果存进 OrbitDB 得到真实内容寻址 CID; 无活跃 channel / 无 LLM 时如实报错。
+    const delegateExecutor = async (req) => {
+        try {
+            const channels = await loadChannels();
+            const active = (() => {
+                try {
+                    const raw = fsSync.existsSync(path.join(process.env.HOME || '/tmp', '.bolloon', 'active-channel.json'))
+                        ? fsSync.readFileSync(path.join(process.env.HOME || '/tmp', '.bolloon', 'active-channel.json'), 'utf-8') : '';
+                    return raw ? JSON.parse(raw) : null;
+                }
+                catch {
+                    return null;
+                }
+            })();
+            const ch = channels.find((c) => c.id === active?.channelId) || channels.find((c) => c.id === active?.id) || channels[0];
+            if (!ch)
+                return { ok: false, summary: 'no local channel to execute with', error: 'no-channel' };
+            const agent = await getAgentForChannel(ch.id, ch.publicKey, ch.name, ch.didDocument);
+            const task = [
+                `【被委派任务 · 能力 ${req.capability}】`,
+                req.instruction,
+                req.docPath ? `\n资料路径: ${req.docPath}` : '',
+                req.docContent ? `\n资料内容:\n${req.docContent}` : '',
+                `\n(来自 agent ${req.fromAgentId || 'unknown'})，请直接给出可交付结果。`,
+            ].join('');
+            const out = await agent.prompt(task);
+            const text = String(out || '').trim();
+            if (!text || text.startsWith('❌') || text.startsWith('[AI 服务调用失败]')) {
+                return { ok: false, summary: text.slice(0, 800) || '(空结果)', error: 'execution-failed' };
+            }
+            // 真结果 → 内容寻址存储 (CID), 失败不编造 CID, 只回摘要
+            let cid;
+            try {
+                const { getCIDDatabase } = await import('../orbitdb/cid-database.js');
+                const rec = await getCIDDatabase().save({ agentId: req.targetAgentId, type: 'context', content: text, metadata: { capability: req.capability, fromAgentId: req.fromAgentId, kind: 'delegate-result' } });
+                cid = rec?.id;
+            }
+            catch { /* 存不上就不给 CID */ }
+            return { ok: true, summary: text.slice(0, 4000), resultCid: cid };
+        }
+        catch (e) {
+            return { ok: false, summary: `delegate executor failed: ${String(e?.message || e).slice(0, 300)}`, error: 'executor-error' };
+        }
+    };
     let agentDelegateMounted = false;
     try {
         const delegateTransport = createIrohDelegateTransport({ verbose: true });
         // 注意: createAgentDelegateApp 内部声明的是绝对路径 (/api/agent/...),
         // 所以挂载时**不能**再带 '/api/agent' 前缀 (否则变成 /api/agent/api/agent/... 恒 404)
-        app.use(createAgentDelegateApp(delegateTransport));
+        app.use(createAgentDelegateApp(delegateTransport, { execute: delegateExecutor }));
         agentDelegateMounted = true;
-        console.log('[agent-delegate] 已挂载到 /api/agent (启动即用: local-manifest / register / pick / delegate)');
+        console.log('[agent-delegate] 已挂载到 /api/agent (启动即用: local-manifest / register / pick / delegate, 真执行器已注入)');
     }
     catch (e) {
         console.warn('[agent-delegate] 挂载失败 (非致命):', e?.message);
@@ -6588,10 +7021,10 @@ ${goalDesc}
             if (!agentDelegateMounted) {
                 try {
                     const delegateTransport = createIrohDelegateTransport({ verbose: true });
-                    const delegateApp = createAgentDelegateApp(delegateTransport);
+                    const delegateApp = createAgentDelegateApp(delegateTransport, { execute: delegateExecutor });
                     app.use(delegateApp);
                     agentDelegateMounted = true;
-                    console.log('[iroh API] agent-delegate app 已挂载到 /api/agent (补挂)');
+                    console.log('[iroh API] agent-delegate app 已挂载到 /api/agent (补挂, 真执行器已注入)');
                 }
                 catch (e) {
                     console.error('[iroh API] 挂载 agent-delegate app 失败:', e);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bolloon/bolloon-agent",
-  "version": "0.4.23",
+  "version": "0.4.25",
   "type": "module",
   "description": "P2P AI Document Agent - 全局安装后执行 `bolloon` 启动产品",
   "main": "dist/cli-entry.js",
@@ -130,7 +130,7 @@
     "vitest": "^5.0.0"
   },
   "build": {
-    "appId": "com.bolloon.agent",
+    "appId": "com.hibs.bolloon",
     "productName": "Bolloon Agent",
     "directories": {
       "output": "release",