@bolloon/bolloon-agent 0.4.24 → 0.4.26

package/dist/agents/runner-resolver.js

@@ -0,0 +1,225 @@
+/**
+ * runner-resolver.ts — 独立宿主的**分阶段**执行器解析 (2026-09-16, 批次 2-C.2)
+ *
+ * 起因: 独立宿主"没有 tick 日志、没有建 Run"这种故障无法定位 —— 20 秒超时只能说"超时",
+ * 说不出卡在哪。这一层把解析拆成有序阶段, 每阶段记 开始/结束/耗时/失败分类/超时原因:
+ *
+ *   resolve_goal → resolve_agent → load_identity → load_session → load_skills
+ *                → init_llm → create_session → prepare_resume → ready
+ *
+ * 任一必需阶段失败 → `{ ok:false, kind:'unresolved', reason:'<阶段>: <原因>', stages }`
+ *  → Supervisor **只诊断**: 不建 Run、不改 Goal 状态、不伪造失败; 原因进 wakeReport/宿主状态。
+ *
+ * 顺带修一个真根因: 独立宿主此前**没有初始化 LLM 层**, 于是 `PiAgentSession.prompt()` 判定
+ * `minimaxAvailable=false` 走 fallback 提前返回 —— 既不调模型也不建 Run, 上层只看到"执行完成但没有 Run"。
+ * 现在 `init_llm` 是必需阶段, LLM 不可用直接 unresolved (而不是偷偷退化成 fallback)。
+ */
+import * as os from 'os';
+import * as path from 'path';
+import * as fsp from 'fs/promises';
+import { readGoal } from './goal-store.js';
+import { buildContinuationPlan } from './run-store.js';
+export const RESOLVE_STAGES = [
+    'resolve_goal',
+    'resolve_agent',
+    'load_identity',
+    'load_session',
+    'load_skills',
+    'init_llm',
+    'create_session',
+    'prepare_resume',
+    'ready',
+];
+function classify(err, stage) {
+    const m = String(err?.message || err || '').toLowerCase();
+    if (m.includes('超时') || m.includes('timeout'))
+        return 'timeout';
+    if (stage === 'init_llm')
+        return 'config';
+    if (m.includes('eacces') || m.includes('enoent') || m.includes('eperm'))
+        return 'io';
+    return 'unknown';
+}
+/** 读本机 LLM 配置摘要 (只看结构与有无, 不打印任何密钥) */
+export async function probeLlmConfig(home = os.homedir()) {
+    try {
+        const raw = JSON.parse(await fsp.readFile(path.join(home, '.bolloon', 'llm-config.json'), 'utf8'));
+        const active = raw.activeProvider || raw.provider;
+        const providers = raw.providers || {};
+        const p = providers[active] || {};
+        const needsKey = p.requiresApiKey !== false;
+        const hasKey = !!(p.apiKey || p.api_key || process.env[`${String(active).toUpperCase()}_API_KEY`]);
+        if (!active)
+            return { ok: false, reason: 'llm-config.json 没有 activeProvider' };
+        if (needsKey && !hasKey)
+            return { ok: false, provider: active, model: p.model, hasKey: false, reason: `provider ${active} 需要 apiKey 但没配` };
+        return { ok: true, provider: active, model: p.model, hasKey };
+    }
+    catch (err) {
+        return { ok: false, reason: `llm-config.json 不可读: ${String(err?.message || err).slice(0, 100)}` };
+    }
+}
+async function stage(stages, name, required, timeoutMs, fn, log, noteOf) {
+    const t0 = Date.now();
+    log?.(`[resolver] ${name} 开始`);
+    try {
+        const value = await Promise.race([
+            fn(),
+            new Promise((_r, rej) => {
+                const t = setTimeout(() => rej(new Error(`${name} 超时 (${timeoutMs}ms)`)), timeoutMs);
+                t.unref?.();
+            }),
+        ]);
+        const report = { stage: name, ok: true, ms: Date.now() - t0, required, note: noteOf?.(value) };
+        stages.push(report);
+        log?.(`[resolver] ${name} 完成 ${report.ms}ms`);
+        return { ok: true, value, report };
+    }
+    catch (err) {
+        const report = {
+            stage: name, ok: false, ms: Date.now() - t0, required,
+            error: String(err?.message || err).slice(0, 200),
+            errorClass: classify(err, name),
+        };
+        stages.push(report);
+        log?.(`[resolver] ${name} 失败 ${report.ms}ms: ${report.error}`);
+        return { ok: false, report };
+    }
+}
+/** 阶段报告一行摘要 (CLI / 日志 / wakeReport 用) */
+export function formatStages(stages) {
+    return stages.map((s) => `${s.stage}${s.ok ? '✓' : '✗'}${s.ms}ms`).join(' → ');
+}
+/**
+ * 分阶段解析"谁来执行这个 Goal"。
+ * 与 web 宿主同构: 都返回一个 runner; 差别只在"用什么上下文建 session"。
+ */
+export async function resolveGoalRunner(req, opts = {}) {
+    const home = opts.home ?? os.homedir();
+    const cwd = opts.cwd ?? process.cwd();
+    const log = opts.log;
+    const stageTimeout = opts.stageTimeoutMs ?? 30_000;
+    const createTimeout = opts.createTimeoutMs ?? (Number(process.env.BOLLOON_SUPERVISE_CREATE_TIMEOUT_MS) || 20_000);
+    const stages = [];
+    const fail = (report, reason) => ({
+        ok: false, kind: 'none', reason, stages, failedStage: report.stage,
+    });
+    if (opts.allow === false) {
+        return fail({ stage: 'resolve_goal', ok: false, ms: 0, required: true, error: '本地执行被显式关闭' }, 'resolve_goal: 本地执行被显式关闭 (BOLLOON_SUPERVISE_AGENT=0) → 只诊断');
+    }
+    // 1. resolve_goal —— 目标是否可执行
+    const g = req.goal;
+    const goalCheck = await stage(stages, 'resolve_goal', true, stageTimeout, async () => {
+        if (!g?.goalId)
+            throw new Error('没有 goalId');
+        const fresh = await readGoal(g.goalId);
+        if (!fresh)
+            throw new Error(`Goal 不存在: ${g.goalId}`);
+        if (fresh.status === 'paused' || fresh.status === 'needs_human')
+            throw new Error(`Goal 状态 ${fresh.status} 不允许自动执行`);
+        return fresh;
+    }, log);
+    if (!goalCheck.ok)
+        return fail(goalCheck.report, `resolve_goal: ${goalCheck.report.error} → 只诊断, Goal 状态未改动`);
+    const goal = goalCheck.value;
+    // 2. resolve_agent —— 用哪个 agent 身份执行
+    const agentCheck = await stage(stages, 'resolve_agent', true, stageTimeout, async () => {
+        if (!goal.channelId && !req.prevRunId)
+            throw new Error('Goal 没有 channelId (无法确定 agent 上下文)');
+        return { channelId: goal.channelId || '', agentId: goal.agentId || '' };
+    }, log);
+    if (!agentCheck.ok)
+        return fail(agentCheck.report, `resolve_agent: ${agentCheck.report.error} → 只诊断 (不建 Run)`);
+    const { channelId, agentId } = agentCheck.value;
+    // 3. load_identity —— 身份可读性 (缺身份不致命, 但要留痕)
+    await stage(stages, 'load_identity', false, stageTimeout, async () => {
+        const files = ['keypair.json', 'agent-registry.json'].map((f) => path.join(home, '.bolloon', f));
+        const found = [];
+        for (const f of files)
+            if (await fsp.stat(f).then(() => true).catch(() => false))
+                found.push(path.basename(f));
+        return found;
+    }, log, (found) => (found.length ? `身份文件: ${found.join(', ')}` : '无身份文件 (用系统临时身份)'));
+    // 4. load_session —— 会话存储可读性
+    await stage(stages, 'load_session', false, stageTimeout, async () => {
+        const dir = path.join(home, '.bolloon', 'sessions');
+        return fsp.stat(dir).then((st) => st.isDirectory()).catch(() => false);
+    }, log, (ok) => (ok ? `会话目录可读: ${path.join(home, '.bolloon', 'sessions')}` : '会话目录不存在 (将新建)'));
+    // 5. load_skills —— 技能视图可读性 (2-G.2 起会变成必需阶段)
+    await stage(stages, 'load_skills', false, stageTimeout, async () => {
+        const { getSkillsManager } = await import('./skills-manager.js');
+        const list = await getSkillsManager({ home, cwd }).view();
+        return { total: list.length, enabled: list.filter((s) => s.status === 'enabled').length, invalid: list.filter((s) => s.status === 'invalid').length };
+    }, log, (r) => `技能视图: ${r.total} 个 (enabled ${r.enabled}, invalid ${r.invalid})`);
+    // 6. init_llm —— **必需**: LLM 可用 (否则 agent 会退化成 fallback, 既不调模型也不建 Run)
+    const llmCheck = await stage(stages, 'init_llm', true, stageTimeout, async () => {
+        const probe = opts.probeLlm ? await opts.probeLlm() : await probeLlmConfig(home);
+        if (!probe.ok)
+            throw new Error(probe.reason || 'LLM 不可用');
+        const { initMinimax } = await import('../constraints/index.js');
+        initMinimax();
+        return probe;
+    }, log, (probe) => `provider=${probe.provider} model=${probe.model ?? '(默认)'} key=${probe.hasKey ? '有' : '免'}`);
+    if (!llmCheck.ok) {
+        return fail(llmCheck.report, `init_llm: ${llmCheck.report.error} → 只诊断 (不发起会退化成 fallback 的执行)`);
+    }
+    // 7. create_session —— 真 agent session
+    let agent;
+    const sessCheck = await stage(stages, 'create_session', true, createTimeout, async () => {
+        if (opts.createAgent) {
+            agent = await opts.createAgent(channelId, goal.goalId);
+            return true;
+        }
+        const { createAgentSession } = await import('./pi-sdk.js');
+        agent = await createAgentSession({ cwd, peerId: `supervise:${channelId || agentId}`, channelId: channelId || undefined }, true);
+        return !!agent;
+    }, log);
+    if (!sessCheck.ok || !agent)
+        return fail(sessCheck.report, `create_session: ${sessCheck.report.error} → 只诊断 (不建 Run)`);
+    // 8. prepare_resume —— 恢复计划 (只读; 真正 prepareResume 由 runner 在运行时做, 保证状态迁移与执行同一时刻)
+    let resumeNote = '新 Run (无历史)';
+    if (req.prevRunId) {
+        const planCheck = await stage(stages, 'prepare_resume', false, stageTimeout, async () => {
+            const plan = await buildContinuationPlan(req.prevRunId);
+            if (!plan)
+                throw new Error(`读不到上一条 Run: ${req.prevRunId}`);
+            resumeNote = `已完成 ${plan.completedSteps.length} 步, 非幂等守卫 ${plan.replayGuards.length} 条`;
+            return plan;
+        }, log);
+        if (!planCheck.ok)
+            resumeNote = `恢复计划读取失败: ${planCheck.report.error}`;
+    }
+    stages.push({ stage: 'ready', ok: true, ms: 0, required: true, note: `runner 就绪 (channel=${channelId || '-'}, ${resumeNote})` });
+    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 };
+        }
+        agent.setGoalId?.(goal.goalId);
+        agent.setContinuationGuards?.(r.guards || []);
+        const reply = await agent.prompt(r.instruction);
+        const runId = agent.getLastRunId?.() || agent.getRunId?.() || '';
+        // 没有 Run = 这次执行没有事实记录: 如实报告, 不让上层把"没跑"当"跑完"
+        if (!runId) {
+            return { status: 'failed', error: `执行没有产生 Run 记录 (agent 可能走了 fallback/未初始化路径): ${String(reply || '').slice(0, 120)}` };
+        }
+        return { runId, status: 'done', reply: typeof reply === 'string' ? reply.slice(0, 500) : undefined };
+    };
+    return { ok: true, kind: 'standalone', runner, stages };
+}
+/** 已启动的独立宿主把最近一次解析报告写给上层 (wakeReport / API / CLI 用) */
+export function latestFailedStage(res) {
+    return { stage: res.failedStage, reason: res.ok ? undefined : res.reason };
+}
+/** 供 CLI/诊断: 一次解析的完整人类可读报告 */
+export function describeResolution(res) {
+    const failed = res.stages.find((s) => !s.ok);
+    const head = res.ok ? '✅ 可执行' : `⛔ 不可执行 (卡在 ${res.failedStage})`;
+    const lines = [`${head}${res.reason ? ` — ${res.reason}` : ''}`, `阶段: ${formatStages(res.stages)}`];
+    for (const s of res.stages)
+        if (s.note)
+            lines.push(`  · ${s.stage}: ${s.note}`);
+    if (failed?.error)
+        lines.push(`  ✗ 失败分类=${failed.errorClass} 原因=${failed.error}`);
+    return lines.join('\n');
+}

package/dist/agents/skill-readiness.js

@@ -0,0 +1,133 @@
+/**
+ * skill-readiness.ts — Goal 级技能快照 + 执行前就绪门禁 (批次 2-G.2, 2026-09-16)
+ *
+ * 定位 (与 leo 的规格一致): 这属于**执行前准备**, 由 Supervisor / runner resolver 负责 ——
+ * **不放进 PiAgentHarness** (Harness 只管"这一段能不能安全执行")。
+ *
+ * 规则:
+ *   · Goal 首次执行时把 requiredSkills 解析成 snapshot (name/version/contentHash/source/resolvedAt) 并冻结;
+ *   · 后续 Run 只认快照: 缺技能 / 未启用 / 损坏 / hash 漂移 / 版本变化 → **不启动 Run**, Goal → needs_human;
+ *   · 前缀 '?' 的技能算可选: 缺失不阻塞, 但写一条 degradation;
+ *   · **不允许静默用新版本** —— 漂移必须人工批准 (approve) 才会更新快照。
+ */
+import * as os from 'os';
+import { SkillsManager } from './skills-manager.js';
+import { readGoal, setContinuation, updateGoal, addEvidence, } from './goal-store.js';
+import { recordDegradation } from './run-store.js';
+export function parseSkillSpecs(list = []) {
+    const required = [];
+    const optional = [];
+    for (const raw of list) {
+        const n = String(raw || '').trim();
+        if (!n)
+            continue;
+        if (n.startsWith('?'))
+            optional.push(n.slice(1).trim());
+        else
+            required.push(n);
+    }
+    return { required, optional };
+}
+function userHome(home) {
+    return home || process.env.HOME || os.homedir();
+}
+function manager(home) {
+    return new SkillsManager({ home: userHome(home), cwd: process.cwd() });
+}
+/** 冻结技能快照 (首次执行时调用; 已冻结则不重复解析) */
+export async function freezeGoalSkills(goal, opts = {}) {
+    const { required } = parseSkillSpecs(goal.requiredSkills || []);
+    if (!required.length)
+        return { ok: true, snapshot: goal.skillSnapshot || [], missing: [], notEnabled: [] };
+    if (goal.skillSnapshot?.length && !opts.force)
+        return { ok: true, snapshot: goal.skillSnapshot, missing: [], notEnabled: [] };
+    const sm = manager(opts.home);
+    const res = await sm.snapshot(required, { home: userHome(opts.home) });
+    if (!res.ok || res.missing.length) {
+        return { ok: false, missing: res.missing, notEnabled: [], reason: `必需技能缺失: ${res.missing.join(', ')}` };
+    }
+    const snapshot = res.entries.map((e) => ({ name: e.name, version: e.version, contentHash: e.contentHash, source: e.source, resolvedAt: e.resolvedAt }));
+    await updateGoal(goal.goalId, { skillSnapshot: snapshot });
+    await addEvidence(goal.goalId, [`技能快照已冻结: ${snapshot.map((x) => `${x.name}@${x.version}:${x.contentHash.slice(0, 8)}`).join(', ')}`]).catch(() => { });
+    return { ok: true, snapshot, missing: [], notEnabled: [] };
+}
+/** 执行前就绪门禁 (Supervisor 每次准备起 Run 之前调) */
+export async function ensureGoalSkillsReady(goal, opts = {}) {
+    const { required, optional } = parseSkillSpecs(goal.requiredSkills || []);
+    const out = { ok: true, missing: [], notEnabled: [], invalid: [], drift: [], degradations: [] };
+    if (!required.length && !optional.length)
+        return out;
+    const frozen = await freezeGoalSkills(goal, opts);
+    if (!frozen.ok) {
+        out.ok = false;
+        out.missing = frozen.missing;
+        out.reason = frozen.reason || '技能快照无法冻结';
+        return out;
+    }
+    const snapshot = frozen.snapshot || [];
+    out.snapshot = snapshot;
+    // 逐个校验快照 (真实 registry + 真实文件 hash)
+    const sm = manager(opts.home);
+    const home = userHome(opts.home);
+    for (const entry of snapshot) {
+        const rec = await sm.inspect(entry.name, { home });
+        if (!rec) {
+            out.missing.push(entry.name);
+            continue;
+        }
+        if (rec.status !== 'enabled' && rec.status !== 'installed')
+            out.notEnabled.push(`${entry.name}(${rec.status})`);
+        if (rec.contentHash !== entry.contentHash)
+            out.drift.push({ name: entry.name, expected: entry.contentHash, actual: rec.contentHash });
+        if (rec.version !== entry.version)
+            out.drift.push({ name: entry.name, expected: entry.version, actual: rec.version });
+        const v = await sm.validate(entry.name, { home }).catch(() => null);
+        if (v && !v.ok)
+            out.invalid.push(`${entry.name}: ${(v.issues || []).slice(0, 2).join('; ')}`);
+    }
+    // 可选技能: 缺失/未启用 → 只记 degradation (不阻塞)
+    for (const name of optional) {
+        const rec = await sm.inspect(name, { home });
+        if (!rec) {
+            out.degradations.push(`可选技能 ${name} 不存在 → 继续执行 (已记降级)`);
+            continue;
+        }
+        if (rec.status !== 'enabled' && rec.status !== 'installed')
+            out.degradations.push(`可选技能 ${name} 未启用 (${rec.status}) → 继续执行`);
+    }
+    if (out.missing.length)
+        out.reason = `必需技能缺失: ${out.missing.join(', ')}`;
+    else if (out.notEnabled.length)
+        out.reason = `必需技能未启用: ${out.notEnabled.join(', ')}`;
+    else if (out.invalid.length)
+        out.reason = `必需技能损坏: ${out.invalid.join(', ')}`;
+    else if (out.drift.length)
+        out.reason = `技能内容漂移 (需人工批准才能升级): ${out.drift.map((d) => `${d.name} ${String(d.expected).slice(0, 8)}→${String(d.actual).slice(0, 8)}`).join(', ')}`;
+    out.ok = !(out.missing.length || out.notEnabled.length || out.invalid.length || out.drift.length);
+    return out;
+}
+/** 门禁不过 → 写清事实并把 Goal 交给人 (不启动 Run, 不伪造失败) */
+export async function blockGoalOnSkills(goalId, res) {
+    const reason = res.reason || '技能未就绪';
+    await setContinuation(goalId, {
+        wakeReason: 'needs_human', autoContinue: false, needsExternal: undefined,
+        skillReadiness: { ok: false, at: new Date().toISOString(), reason, missing: res.missing, drift: res.drift, degradations: res.degradations },
+    });
+    await updateGoal(goalId, { status: 'needs_human' }).catch(() => { });
+    await addEvidence(goalId, [`技能门禁拦截: ${reason}`]).catch(() => { });
+    for (const d of res.degradations)
+        await recordDegradation({ kind: 'observational', op: 'skill-readiness', message: d }).catch(() => { });
+}
+/** 人工批准技能升级: 重新冻结快照 (显式动作, 不隐式切换) */
+export async function approveSkillUpgrade(goalId, opts = {}) {
+    const goal = await readGoal(goalId);
+    if (!goal)
+        return { ok: false, reason: 'Goal 不存在' };
+    const frozen = await freezeGoalSkills(goal, { ...opts, force: true });
+    if (!frozen.ok)
+        return { ok: false, reason: frozen.reason };
+    await setContinuation(goalId, { skillReadiness: { ok: true, at: new Date().toISOString(), reason: '人工批准技能升级' }, wakeReason: 'active', autoContinue: true });
+    await updateGoal(goalId, { status: 'active' }).catch(() => { });
+    await addEvidence(goalId, [`技能升级已被人工批准: ${(frozen.snapshot || []).map((s) => `${s.name}@${s.version}`).join(', ')}`]).catch(() => { });
+    return { ok: true, snapshot: frozen.snapshot };
+}

package/dist/agents/skill-supervisor-link.js

@@ -0,0 +1,70 @@
+/**
+ * skill-supervisor-link.ts — 技能状态与长期执行的联动 (批次 2-G.4, 2026-09-16)
+ *
+ * 规则 (与 leo 的规格一致):
+ *   · 技能导入成功 / 又能用了 → 被它拦住的 Goal 重新冻结快照并回到 active (等 Supervisor 继续调度);
+ *   · 技能被禁用 / 隔离 / 内容漂移 → **不打断正在跑的 Run**, 但下一次 Run 之前 readiness 必然失败 (2-G.2 门禁) → needs_human;
+ *   · 漂移**不允许隐式切换版本**: 继续固定旧快照, 或等人工 approve 升级 (approveSkillUpgrade)。
+ *
+ * 这里只改"该不该继续"的事实, 不直接启动执行 —— 执行权始终在 Supervisor。
+ */
+import { listGoals } from './goal-store.js';
+import { ensureGoalSkillsReady, blockGoalOnSkills, approveSkillUpgrade, parseSkillSpecs } from './skill-readiness.js';
+import { SkillsManager } from './skills-manager.js';
+import { recordDegradation } from './run-store.js';
+/**
+ * 重评所有"因技能被拦"的 Goal。
+ * @param opts.action 触发原因 (import / enable / disable / quarantine / drift) —— 只用于事实记录
+ */
+export async function reconsiderSkillBlockedGoals(opts = {}) {
+    const out = { rechecked: 0, resumed: [], stillBlocked: [] };
+    const home = opts.home;
+    const goals = await listGoals({ limit: 200 });
+    const interesting = goals.filter((g) => {
+        const r = g.continuation?.skillReadiness;
+        const specs = parseSkillSpecs(g.requiredSkills || []);
+        return (r && r.ok === false) || specs.required.length > 0;
+    });
+    for (const g of interesting) {
+        // 只处理"被技能拦住"的 Goal: 其它原因等人的不要乱动
+        const blockedBySkill = g.continuation?.skillReadiness?.ok === false;
+        if (!blockedBySkill)
+            continue;
+        // 若是被人工标记 needs_human 且与技能无关, 跳过
+        out.rechecked++;
+        const res = await ensureGoalSkillsReady(g, { home });
+        if (res.ok) {
+            // 技能恢复了 → 重新冻结快照 + 回 active (Supervisor 下一轮继续)
+            const approved = await approveSkillUpgrade(g.goalId, { home });
+            if (approved.ok) {
+                out.resumed.push(g.goalId);
+                console.log(`[skill-link] ${g.goalId} 技能已恢复 (${opts.action || 'unknown'}${opts.name ? `:${opts.name}` : ''}) → 重新冻结快照并回到 active`);
+            }
+            else {
+                out.stillBlocked.push(g.goalId);
+            }
+        }
+        else {
+            await blockGoalOnSkills(g.goalId, res);
+            out.stillBlocked.push(g.goalId);
+        }
+    }
+    return out;
+}
+/** 技能被禁用/隔离/漂移时, 把依赖它的活跃 Goal 标清事实 (不打断当前 Run) */
+export async function markDependentsOfSkill(name, opts = { reason: '技能不可用' }) {
+    const sm = new SkillsManager({ home: opts.home, cwd: process.cwd() });
+    const health = await sm.health({ home: opts.home }).catch(() => null);
+    const goals = await listGoals({ limit: 200 });
+    const affected = [];
+    for (const g of goals) {
+        const { required } = parseSkillSpecs(g.requiredSkills || []);
+        if (!required.includes(name))
+            continue;
+        if (['completed', 'failed', 'abandoned'].includes(g.status))
+            continue;
+        affected.push(g.goalId);
+        await recordDegradation({ kind: 'observational', op: 'skill-link', message: `Goal ${g.goalId} 依赖的技能 ${name} 状态: ${JSON.stringify(health?.byStatus || {})} (${opts.reason}) — 下一次 Run 前会重新门禁` }).catch(() => { });
+    }
+    return affected;
+}