@bolloon/bolloon-agent 0.4.25 → 0.4.26

package/dist/agents/execution-supervisor.js

@@ -68,7 +68,7 @@ export function decideGoalOutcome(goal, run, opts = {}) {
                 reason: `运行被中止 (${run.errorClass || run.error || '预算/人工'}): 目标仍 active, 交给下一个 Run 继续`,
             };
         case 'done': {
-            const verdict = evaluateGoalCompletion(goal);
+            const verdict = evaluateGoalCompletion(goal, { lastRunStatus: opts.lastRunStatus || run.status });
             if (verdict.complete) {
                 return {
                     goalStatus: 'completed',
@@ -205,6 +205,18 @@ export class ExecutionSupervisor {
                     this.log(`[supervisor] 对账: ${report.reconciled.interrupted.length} 条僵尸 run → interrupted`);
             }
             report.supervised = await superviseRuns();
+            // 1.5 (2026-09-16, 2-C.4): 外部等待超时 → 明确转人工 (不允许无限等待)
+            try {
+                const { expireExternalWaits } = await import('./external-events.js');
+                const expired = await expireExternalWaits({ now: this.now() });
+                for (const e of expired) {
+                    this.log(`[supervisor] 外部等待超时 → needs_human: ${e.goalId} (${e.wait.expectedSource})`);
+                    this.emit({ kind: 'needs_human', goalId: e.goalId, message: e.reason });
+                }
+            }
+            catch (err) {
+                this.log(`[supervisor] 外部等待超时检查失败: ${err?.message}`);
+            }
             // 2. 扫描可执行 Goal
             const { runnable, skipped } = await listRunnableGoals({ now: this.now(), owner: this.owner });
             report.skipped = skipped;
@@ -303,6 +315,27 @@ export class ExecutionSupervisor {
             report.skipped.push({ goalId: goal.goalId, reason: '无执行器 (Goal 状态未改动)' });
             return { goalId: goal.goalId, status: 'unresolved' };
         }
+        // 2026-09-16 (2-G.2): 执行前技能就绪门禁 —— 缺/未启用/损坏/漂移 → 不启动 Run, Goal → needs_human
+        try {
+            const { ensureGoalSkillsReady, blockGoalOnSkills } = await import('./skill-readiness.js');
+            const ready = await ensureGoalSkillsReady(goal);
+            for (const d of ready.degradations)
+                this.log(`[supervisor] goal=${goal.goalId} 技能降级: ${d}`);
+            if (!ready.ok) {
+                await blockGoalOnSkills(goal.goalId, ready);
+                report.skipped.push({ goalId: goal.goalId, reason: `技能未就绪: ${ready.reason}` });
+                this.emit({ kind: 'needs_human', goalId: goal.goalId, message: ready.reason || '技能未就绪' });
+                this.log(`[supervisor] goal=${goal.goalId} 技能门禁拦截 → needs_human (未启动 Run): ${ready.reason}`);
+                return { goalId: goal.goalId, runId: prevRunId, status: 'blocked_by_skills', error: ready.reason };
+            }
+        }
+        catch (err) {
+            // 门禁自身失败 → fail-closed: 不执行 (宁可停, 不用未校验的技能跑)
+            const why = `技能门禁自身失败 (fail-closed, 未执行): ${String(err?.message || err).slice(0, 140)}`;
+            report.skipped.push({ goalId: goal.goalId, reason: why });
+            this.log(`[supervisor] ${why}`);
+            return { goalId: goal.goalId, runId: prevRunId, status: 'blocked_by_skills', error: why };
+        }
         // 执行期间持续续租: 续租失败 = 已被别人接管 → 记录 (不掩盖)
         const hb = setInterval(() => {
             void heartbeatGoal(goal.goalId, leaseId, this.leaseTtlMs).then((r) => {
@@ -329,7 +362,28 @@ export class ExecutionSupervisor {
             // 新 Run 必须挂在同一 Goal 下; 没挂上就是执行器没接住 goalId → 如实记, 不掩盖
             report.errors.push(`${goal.goalId}: 新 Run ${finalRunId} 未绑定本 Goal (goalId=${finalRun.goalId || '空'})`);
         }
-        const decision = decideGoalOutcome(goal, finalRun, { now: this.now(), maxAttempts: this.maxRetries });
+        // 2026-09-16 (2-F): 决策前先做两件事 —— ① 跨 Run 汇总证据; ② 没判据就提候选 (未确认 → 不许完成)。
+        //   放在决策之前, 因为"有没有判据/判据是否被满足"正是决策的输入 (之前放在 completed 分支里 = 永远轮不到)。
+        try {
+            const { aggregateEvidence, proposeForGoal } = await import('./goal-criteria.js');
+            await aggregateEvidence(goal.goalId);
+            const refreshedBefore = await readGoal(goal.goalId);
+            // 只在"这一轮正常跑完"时提候选判据 —— 失败/中断要留给 retry 退避逻辑, 不能把重试变成"交人"
+            const ranClean = String(finalRun?.status || '') === 'done';
+            if (ranClean && refreshedBefore && !refreshedBefore.successCriteria.length && !['completed', 'failed', 'abandoned'].includes(refreshedBefore.status)) {
+                const p = await proposeForGoal(goal.goalId);
+                if (p.ok)
+                    this.log(`[supervisor] goal=${goal.goalId} 已提候选判据 (待确认, 未确认前不会判完成)`);
+                else
+                    this.log(`[supervisor] goal=${goal.goalId} 判据生成失败 → 交人: ${p.reason}`);
+            }
+        }
+        catch (err) {
+            this.log(`[supervisor] 证据/判据处理失败: ${err?.message}`);
+        }
+        // 重新读一次 Goal: Run 期间判据可能已被满足 (否则会拿旧快照判决)
+        const goalForDecision = (await readGoal(goal.goalId)) || goal;
+        const decision = decideGoalOutcome(goalForDecision, finalRun, { now: this.now(), maxAttempts: this.maxRetries, lastRunStatus: finalRun?.status });
         await this.applyDecision(goal, decision, finalRun);
         this.emit({ kind: 'goal_decision', goalId: goal.goalId, runId: finalRunId, message: `${finalRun?.status || result.status || '?'} → ${decision.goalStatus}: ${decision.reason}` });
         this.log(`[supervisor] goal=${goal.goalId} run=${finalRunId || '-'} ${finalRun?.status || result.status || '?'} → goal=${decision.goalStatus} (${decision.reason}) ${Date.now() - t0}ms`);
@@ -346,6 +400,7 @@ export class ExecutionSupervisor {
         }
         // 唯一完成出口: 只有经 completeGoalIfEligible 才能把 Goal 判成 completed
         if (decision.goalStatus === 'completed') {
+            // 完成门 (判据存在 + 已确认 + 全满足 + 有证据 + 无未解决项 + 最近 Run 健康)
             const r = await completeGoalIfEligible(goal.goalId);
             if (!r.ok) {
                 // 完成门拒绝 → 如实退回 active, 并保留原因 (不许装作完成)

package/dist/agents/external-events.js

@@ -0,0 +1,162 @@
+/**
+ * external-events.ts — 外部等待 / 外部事件唤醒协议 (批次 2-C.4, 2026-09-16)
+ *
+ * 问题: `notifyExternal()` 之前只是个手动入口 (CLI `/wake`、`POST /api/goals/:id/wake`) ——
+ *       真实 P2P / delegate 回包到达时**没有任何东西**知道该唤醒哪个 Goal, 也没有来源/关联/去重/过期校验。
+ *
+ * 协议 (与 leo 的规格 1:1):
+ *   Goal 在等待时必须绑定: externalRequestId · continuationId · expectedSource · expectedEvent · createdAt · expiresAt
+ *   收到事件时必须依次: ① 校验来源 ② 校验 correlation ③ 校验属于当前 continuation
+ *                    ④ 用 eventId 去重 ⑤ 写入事件事实 (Goal 证据) ⑥ 唤醒 Goal ⑦ 由 Supervisor 下一轮继续
+ *   **事件处理器不直接启动 agent** —— 它只写事实 + 唤醒; 谁来执行由 Supervisor 决定。
+ */
+import { readGoal, setContinuation, updateGoal, listGoals, addEvidence, } from './goal-store.js';
+// ── 绑定等待 ────────────────────────────────────────────────────────────────
+export function defaultWaitExpiry(now = Date.now(), ttlMs = 30 * 60_000) {
+    return new Date(now + ttlMs).toISOString();
+}
+/** 生成 continuationId / requestId (调用方也可自带) */
+export function newContinuationId(goalId) {
+    return `${goalId}:c${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+}
+/**
+ * 把"这个 Goal 在等什么外部事件"写进 Goal continuation (持久化)。
+ * 事件处理器只读这份事实, 不猜。
+ */
+export async function bindExternalWait(goalId, wait) {
+    const rec = await setContinuation(goalId, { external: wait, needsExternal: wait.note || `${wait.expectedSource}${wait.expectedEvent ? `:${wait.expectedEvent}` : ''} (requestId=${wait.requestId})` });
+    // 等待中也要让状态机一致: awaiting_external 由调用方/reducer 设置, 这里只保证等待事实在
+    return rec;
+}
+/** 清掉等待事实 (唤醒/超时后) */
+export async function clearExternalWait(goalId) {
+    return setContinuation(goalId, { external: undefined });
+}
+// ── 匹配 ────────────────────────────────────────────────────────────────────
+function sourceMatches(expected, actual) {
+    if (expected === 'any')
+        return true;
+    return expected === actual;
+}
+async function candidates(event) {
+    const out = [];
+    if (event.goalId) {
+        const g = await readGoal(event.goalId);
+        if (g?.continuation?.external)
+            out.push({ goal: g, wait: g.continuation.external });
+        return out;
+    }
+    const all = await listGoals({ limit: 200 });
+    for (const g of all) {
+        const w = g.continuation?.external;
+        if (w)
+            out.push({ goal: g, wait: w });
+    }
+    return out;
+}
+/**
+ * 投递一个外部事件。校验顺序固定: 来源 → correlation → 属于当前 continuation → 过期 → 去重。
+ * 任何一步不过 → **不唤醒**, 只返回原因 (调用方可以把不匹配的事件当普通消息继续走)。
+ */
+export async function deliverExternalEvent(event, deps = {}) {
+    const now = deps.now ? deps.now() : Date.now();
+    if (!event?.eventId)
+        return { ok: false, reason: 'correlation_mismatch', detail: '事件缺少 eventId (无法去重)' };
+    const cands = await candidates(event);
+    if (cands.length === 0)
+        return { ok: false, reason: 'no_match', detail: '没有 Goal 在等这个事件' };
+    // 选出唯一匹配的 Goal (按 requestId/continuationId 精确; 退而按来源+事件名)
+    let chosen;
+    let failReason;
+    let failDetail;
+    for (const c of cands) {
+        const w = c.wait;
+        if (!sourceMatches(w.expectedSource, event.source)) {
+            failReason ??= 'source_mismatch';
+            failDetail ??= `等待 ${w.expectedSource}, 收到 ${event.source}`;
+            continue;
+        }
+        if (event.requestId && event.requestId !== w.requestId) {
+            failReason ??= 'correlation_mismatch';
+            failDetail ??= `requestId 不匹配 (等 ${w.requestId}, 收到 ${event.requestId})`;
+            continue;
+        }
+        if (!event.requestId && event.continuationId && event.continuationId !== w.continuationId) {
+            failReason ??= 'correlation_mismatch';
+            failDetail ??= 'continuationId 不匹配';
+            continue;
+        }
+        if (!event.requestId && !event.continuationId) {
+            failReason ??= 'correlation_mismatch';
+            failDetail ??= '事件没有 requestId/continuationId, 不能确认属于这次等待';
+            continue;
+        }
+        if (w.expectedEvent && event.eventName && event.eventName !== w.expectedEvent) {
+            failReason ??= 'event_mismatch';
+            failDetail ??= `等 ${w.expectedEvent}, 收到 ${event.eventName}`;
+            continue;
+        }
+        chosen = c;
+        break;
+    }
+    if (!chosen)
+        return { ok: false, reason: failReason || 'no_match', detail: failDetail };
+    const { goal, wait } = chosen;
+    // 过期
+    if (Date.parse(wait.expiresAt) <= now) {
+        return { ok: false, reason: 'expired', goalId: goal.goalId, detail: `等待已过期 (${wait.expiresAt})` };
+    }
+    // 去重 (同一 eventId 只处理一次; 跨进程看盘上事实)
+    const seen = goal.continuation?.deliveredEventIds || [];
+    if (seen.includes(event.eventId))
+        return { ok: false, reason: 'duplicate', goalId: goal.goalId, detail: `eventId ${event.eventId} 已处理过` };
+    // 写入事件事实 (证据 + 去重表) —— 不在这里启动 agent
+    await addEvidence(goal.goalId, [
+        `外部事件 (${event.source}${event.fromDid ? `, ${String(event.fromDid).slice(0, 16)}…` : ''}): ${event.eventName || '结果'} eventId=${event.eventId} requestId=${event.requestId || '-'} payload=${JSON.stringify(event.payload ?? null).slice(0, 300)}`,
+    ]).catch(() => { });
+    await setContinuation(goal.goalId, {
+        deliveredEventIds: [...seen, event.eventId].slice(-20),
+        external: undefined,
+        externalResult: { eventId: event.eventId, source: event.source, fromDid: event.fromDid, at: new Date(now).toISOString(), payload: event.payload },
+        wakeReason: 'active',
+        needsExternal: undefined,
+        autoContinue: true,
+        wakeAt: undefined,
+    });
+    // 状态拉回 active (只有还在"等外部"的状态才动它) —— Supervisor 下一轮才会真的执行
+    try {
+        if (['awaiting_external', 'retry_wait', 'recovering'].includes(String(goal.status))) {
+            await updateGoal(goal.goalId, { status: 'active' });
+        }
+    }
+    catch { /* 状态写失败 → 下一轮仍会跳过等待; 事件事实已写入, 不丢 */ }
+    // 唤醒 (由 Supervisor 下一轮真正执行)
+    let woke = false;
+    if (deps.wake)
+        woke = await deps.wake(goal.goalId).catch(() => false);
+    return { ok: true, reason: 'delivered', goalId: goal.goalId, woke };
+}
+/**
+ * 把所有"等待已过期"的 Goal 转成明确状态 (needs_human, autoContinue=false)。
+ * 由 Supervisor 每轮 tick 开头调用 —— 超时不是失败, 但不能无限等。
+ */
+export async function expireExternalWaits(opts = {}) {
+    const now = opts.now ?? Date.now();
+    const goals = opts.goalIds
+        ? (await Promise.all(opts.goalIds.map((id) => readGoal(id)))).filter(Boolean)
+        : await listGoals({ limit: 200 });
+    const out = [];
+    for (const g of goals) {
+        const w = g.continuation?.external;
+        if (!w)
+            continue;
+        if (Date.parse(w.expiresAt) > now)
+            continue;
+        const reason = `外部事件超时 (${w.expectedSource}${w.expectedEvent ? `:${w.expectedEvent}` : ''}, requestId=${w.requestId}, 过期于 ${w.expiresAt}) → 转人工`;
+        out.push({ goalId: g.goalId, wait: w, reason });
+        await setContinuation(g.goalId, { external: undefined, wakeReason: 'needs_human', needsExternal: undefined, autoContinue: false, lastExternalTimeout: reason });
+        await updateGoal(g.goalId, { status: 'needs_human' }).catch(() => { });
+        await addEvidence(g.goalId, [`外部事件超时: ${reason}`]).catch(() => { });
+    }
+    return out;
+}

package/dist/agents/goal-criteria.js

@@ -0,0 +1,124 @@
+/**
+ * goal-criteria.ts — 判据生成 / 确认 / 跨 Run 证据汇总 (批次 2-F, 2026-09-16)
+ *
+ * 规则 (与 leo 的规格一致):
+ *   · 用户明确给出完成条件 → 直接使用 (criteriaSource = 'user', 已确认);
+ *   · 用户没给 → **agent 提候选判据** (criteriaSource = 'agent_proposed', 未确认);
+ *     候选判据**不能**直接成为最终完成条件 —— 未确认就永不自动完成;
+ *   · 目标过于模糊 / 候选生成失败 → **不自动完成**, 交人 (needs_human);
+ *   · 证据跨 Run 汇总 (Run 证据 → Goal 证据, 去重), unresolvedItems 跨 Run 保留。
+ */
+import { readGoal, setCriteria, addEvidence, updateGoal, } from './goal-store.js';
+import { readRun } from './run-store.js';
+/** 太模糊的目标: 判据无从谈起 (短且没有可核验的动作词) */
+export function looksVague(objective) {
+    const o = String(objective || '').trim();
+    if (!o)
+        return { vague: true, reason: '目标为空' };
+    const hasVerb = /(写|改|建|加|删|修|跑|测|验证|发布|提交|导出|生成|读|查|部署|完成|实现|接入|更新|安装|配置|整理|对比|汇总)/.test(o);
+    if (o.length <= 4 && !hasVerb)
+        return { vague: true, reason: `目标太短且没有可核验动作: "${o}"` };
+    if (/^(优化|改进|提升|完善|处理|搞|弄|看看|研究一下)/.test(o) && o.length < 12) {
+        return { vague: true, reason: `目标过于笼统: "${o}" (缺可核验的产出)` };
+    }
+    return { vague: false };
+}
+/**
+ * 从目标推导候选判据 (确定性启发式, 不依赖 LLM —— 生成失败也不会伪造成功)。
+ * 候选**必须**经人确认才能用作完成条件。
+ */
+export function proposeCriteria(objective) {
+    const v = looksVague(objective);
+    if (v.vague)
+        return { ok: false, criteria: [], needsHuman: true, reason: `无法生成可核验判据: ${v.reason} → 请补一句"做完的样子"` };
+    const o = String(objective).trim();
+    const out = [];
+    // 动作拆解: 目标里出现的"动作 + 对象"直接成为候选
+    const actions = ['写出', '创建', '修改', '删除', '跑通', '验证', '发布', '提交', '导出', '生成', '读入', '部署', '安装', '配置', '整理', '汇总', '对比'];
+    const hits = actions.filter((a) => o.includes(a));
+    for (const h of hits.slice(0, 3))
+        out.push(`完成"${h}"这一步并留下可核验产物`);
+    if (!out.length)
+        out.push(`产出与目标一致的结果: ${o.slice(0, 60)}`);
+    out.push('有证据可复现 (命令/文件/输出留痕)');
+    out.push('没有遗留未解决项');
+    return { ok: true, criteria: out.slice(0, 5) };
+}
+/** 给 Goal 提候选判据 (不确认; 留痕) */
+export async function proposeForGoal(goalId) {
+    const goal = await readGoal(goalId);
+    if (!goal)
+        return { ok: false, criteria: [], needsHuman: true, reason: 'Goal 不存在' };
+    if (goal.successCriteria.length && goal.criteriaSource === 'user') {
+        return { ok: true, criteria: goal.successCriteria, reason: '用户已给出判据 (不改)' };
+    }
+    const p = proposeCriteria(goal.objective);
+    if (!p.ok) {
+        // 太模糊 → 明确交人, 不写假判据
+        await addEvidence(goalId, [`判据生成失败: ${p.reason}`]).catch(() => { });
+        await updateGoal(goalId, { status: 'needs_human' }).catch(() => { });
+        return p;
+    }
+    await setCriteria(goalId, { criteria: p.criteria, source: 'agent_proposed', confirm: false });
+    await addEvidence(goalId, [`agent 提出候选判据 (待确认): ${p.criteria.join(' / ')}`]).catch(() => { });
+    return p;
+}
+/** 人确认判据 (可同时改内容) */
+export async function confirmCriteria(goalId, opts = {}) {
+    const goal = await readGoal(goalId);
+    if (!goal)
+        return { ok: false, reason: 'Goal 不存在' };
+    const criteria = opts.criteria?.length ? opts.criteria : goal.successCriteria;
+    if (!criteria.length)
+        return { ok: false, reason: '没有可确认的判据 (先给判据或让 agent 提候选)' };
+    const next = await setCriteria(goalId, { criteria, source: opts.criteria?.length ? 'user' : (goal.criteriaSource || 'user'), confirm: true, by: opts.by || 'human' });
+    await addEvidence(goalId, [`判据已确认 (v${next?.criteriaVersion}): ${criteria.join(' / ')}`]).catch(() => { });
+    return { ok: true, goal: next };
+}
+/** 把 Goal 名下所有 Run 的证据汇总进 Goal.evidence (去重, 保留跨 Run 历史) */
+export async function aggregateEvidence(goalId) {
+    const goal = await readGoal(goalId);
+    if (!goal)
+        return { runs: 0, runEvidence: [], goalEvidence: [], unresolved: [] };
+    const runEvidence = [];
+    let lastRunStatus;
+    for (const rid of goal.runs || []) {
+        const run = await readRun(rid).catch(() => null);
+        if (!run)
+            continue;
+        lastRunStatus = run.status;
+        for (const ev of (run.evidence || []))
+            runEvidence.push(`[${rid.slice(0, 8)} ${run.status}] ${String(ev).slice(0, 200)}`);
+    }
+    const merged = [...new Set([...(goal.evidence || []), ...runEvidence])].slice(-50);
+    if (merged.length !== (goal.evidence || []).length) {
+        await updateGoal(goalId, { evidence: merged }).catch(() => { });
+    }
+    return { runs: (goal.runs || []).length, runEvidence, goalEvidence: merged, unresolved: goal.unresolvedItems || [], lastRunStatus };
+}
+/** 长期完成的整体判据 (给 CLI/Web/Supervisor 一个统一解释) */
+export async function longTermStatus(goalId) {
+    const goal = await readGoal(goalId);
+    if (!goal)
+        return { canComplete: false, reason: 'Goal 不存在', checks: {} };
+    const sum = await aggregateEvidence(goalId);
+    const checks = {
+        hasCriteria: goal.successCriteria.length > 0,
+        criteriaConfirmed: goal.criteriaConfirmed === true && goal.criteriaSource !== undefined,
+        allSatisfied: goal.successCriteria.length > 0 && goal.successCriteria.every((_, i) => goal.completedCriteria.includes(i)),
+        hasEvidence: (sum.goalEvidence || []).length > 0,
+        noUnresolved: (goal.unresolvedItems || []).length === 0,
+        lastRunHealthy: !sum.lastRunStatus || !['failed', 'interrupted', 'stalled'].includes(String(sum.lastRunStatus)),
+    };
+    const canComplete = Object.values(checks).every(Boolean);
+    const firstFail = Object.entries(checks).find(([, v]) => !v)?.[0];
+    const reasonMap = {
+        hasCriteria: '没有完成判据',
+        criteriaConfirmed: '判据未经人确认 (候选判据不算数)',
+        allSatisfied: '还有判据没满足',
+        hasEvidence: '没有证据',
+        noUnresolved: '还有未解决项',
+        lastRunHealthy: `最近一条 Run 状态异常 (${sum.lastRunStatus})`,
+    };
+    return { canComplete, reason: canComplete ? '判据全满足 + 已确认 + 有证据 + 无未解决项' : (reasonMap[firstFail] || '未满足完成条件'), checks };
+}

package/dist/agents/goal-store.js

@@ -53,12 +53,34 @@ export function newGoalId() {
     return `g-${Date.now().toString(36)}-${crypto.randomBytes(3).toString('hex')}`;
 }
 export async function createGoal(opts) {
+    // 2026-09-16 (Phase 3 硬门禁): 初始化未就绪时**不允许创建长期 Goal**。
+    //   生产环境生效; 测试环境跳过 (用例跑在隔离 HOME, 本来就没有真实配置)。
+    if (!process.env.VITEST && process.env.BOLLOON_SETUP_IN_PROGRESS !== '1') {
+        try {
+            const { getSetupGateCached } = await import('../setup/setup-store.js');
+            const { gate, state } = await getSetupGateCached();
+            if (gate !== 'ready') {
+                throw new Error(`初始化未就绪 (${gate}, 阶段 ${state.stage}) — 不允许创建 Goal; 先 \`bolloon setup\``);
+            }
+        }
+        catch (err) {
+            if (/初始化未就绪/.test(String(err?.message || '')))
+                throw err;
+            // 门禁自身不可读 → fail-closed (不放行)
+            throw new Error(`初始化状态不可读, 拒绝创建 Goal (fail-closed): ${String(err?.message || err).slice(0, 120)}`);
+        }
+    }
     const now = new Date().toISOString();
     const rec = {
         goalId: newGoalId(),
         objective: String(opts.objective || '').slice(0, 500),
         successCriteria: (opts.successCriteria || []).map((c) => String(c).slice(0, 200)).slice(0, 20),
+        // 用户明确给出判据 → 直接视为已确认 (criteriaSource=user); 没给 → unknown, 之后由 agent 提候选
+        criteriaSource: (opts.successCriteria && opts.successCriteria.length) ? 'user' : 'unknown',
+        criteriaConfirmed: !!(opts.successCriteria && opts.successCriteria.length),
+        criteriaVersion: 1,
         constraints: (opts.constraints || []).map((c) => String(c).slice(0, 200)).slice(0, 20),
+        requiredSkills: (opts.requiredSkills || []).map((c) => String(c).slice(0, 120)).slice(0, 20),
         budget: opts.budget,
         status: 'open',
         channelId: opts.channelId,
@@ -180,10 +202,22 @@ export async function addEvidence(goalId, evidence) {
  *   全部必要判据满足 + 有证据 + 无未解决项 → 才允许 completed。
  *   未声明 successCriteria 的目标**永不**自动完成 (需要人显式确认) —— 否则"模型说完成"就变成了完成。
  */
-export function evaluateGoalCompletion(goal) {
+export function evaluateGoalCompletion(goal, opts = {}) {
     if (!goal.successCriteria.length) {
         return { complete: false, reason: '未声明 successCriteria: 不允许自动判完成 (需人工确认)', missing: [] };
     }
+    // 2-F: 候选判据 (未确认) 不许当作完成条件
+    if (goal.criteriaSource === 'agent_proposed' && goal.criteriaConfirmed !== true) {
+        return { complete: false, reason: `判据是 agent 提的候选 (v${goal.criteriaVersion || 1}), 未经人确认 → 不许判完成`, missing: goal.successCriteria };
+    }
+    if (goal.criteriaConfirmed === false) {
+        return { complete: false, reason: '判据未确认 → 不许判完成', missing: goal.successCriteria };
+    }
+    // 2-F: 最近一条 Run 还处于"没跑完"的状态 (失败/中断/失速) → 不许判完成
+    const lastRunStatus = opts.lastRunStatus;
+    if (lastRunStatus && ['failed', 'interrupted', 'stalled'].includes(String(lastRunStatus))) {
+        return { complete: false, reason: `最近一条 Run 状态是 ${lastRunStatus} (未处理好) → 不许判完成`, missing: [] };
+    }
     const missing = goal.successCriteria
         .map((c, i) => ({ c, i }))
         .filter(({ i }) => !goal.completedCriteria.includes(i))
@@ -199,12 +233,51 @@ export function evaluateGoalCompletion(goal) {
     }
     return { complete: true, reason: '全部判据满足 + 有证据 + 无未解决项', missing: [] };
 }
+/**
+ * 设置/确认判据 (2-F)。
+ *   source: 谁给的 (user 显式给 / agent_proposed 候选 / imported)
+ *   confirm: 是否视为已确认 —— **候选判据必须显式 confirm 才可能完成**
+ */
+export async function setCriteria(goalId, opts) {
+    return withGoalLock(goalId, async () => {
+        const rec = await readGoal(goalId);
+        if (!rec)
+            return null;
+        if (opts.criteria) {
+            rec.successCriteria = opts.criteria.map((c) => String(c).slice(0, 200)).slice(0, 20);
+            rec.criteriaVersion = (rec.criteriaVersion || 1) + 1;
+            rec.completedCriteria = []; // 判据变了 → 之前的满足记录作废 (避免拿旧判据凑完成)
+        }
+        if (opts.source)
+            rec.criteriaSource = opts.source;
+        if (opts.confirm !== undefined) {
+            rec.criteriaConfirmed = opts.confirm;
+            rec.criteriaConfirmedBy = opts.confirm ? (opts.by || 'human') : undefined;
+            rec.criteriaConfirmedAt = opts.confirm ? new Date().toISOString() : undefined;
+        }
+        if (opts.source === 'agent_proposed' && !opts.confirm)
+            rec.proposedCriteria = rec.successCriteria;
+        rec.updatedAt = new Date().toISOString();
+        await writeGoal(rec);
+        return rec;
+    });
+}
 /** 通过完成门就落 completed, 否则保持原状态并回传原因 (不静默) */
 export async function completeGoalIfEligible(goalId) {
     const goal = await readGoal(goalId);
     if (!goal)
         return { ok: false, reason: `goal 不存在: ${goalId}`, goal: null };
-    const verdict = evaluateGoalCompletion(goal);
+    // 2-F: 把"最近一条 Run 的真实状态"一起纳入完成门 (失败/中断/失速时不许判完成)
+    let lastRunStatus;
+    try {
+        const lastRunId = goal.currentRunId || goal.runs?.[goal.runs.length - 1];
+        if (lastRunId) {
+            const { readRun } = await import('./run-store.js');
+            lastRunStatus = (await readRun(lastRunId))?.status;
+        }
+    }
+    catch { /* 读不到就不加这一条约束, 其余判据照旧 */ }
+    const verdict = evaluateGoalCompletion(goal, { lastRunStatus });
     if (!verdict.complete)
         return { ok: false, reason: verdict.reason, goal, missing: verdict.missing };
     const next = await updateGoal(goalId, {
@@ -441,8 +514,10 @@ export async function wakeReport(now = Date.now()) {
             const left = Math.round((Date.parse(c.wakeAt) - now) / 1000);
             wake = `等时间 (${c.wakeAt}, 还剩 ${left}s${c.attempts ? `, 已自动继续 ${c.attempts} 次` : ''})`;
         }
-        else if (c?.wakeReason === 'awaiting_external')
-            wake = `等外部事件${c.needsExternal ? ` (${c.needsExternal})` : ''}`;
+        else if (g.status === 'awaiting_external' || c?.wakeReason === 'awaiting_external' || c?.external) {
+            const what = c?.needsExternal || (c?.external ? `${c.external.expectedSource}${c.external.expectedEvent ? `:${c.external.expectedEvent}` : ''} (requestId=${c.external.requestId}, 过期 ${c.external.expiresAt})` : '');
+            wake = `等外部事件${what ? ` (${what})` : ''}`;
+        }
         else if (live)
             wake = `已被 ${lease.owner} 认领`;
         out.push({ goalId: g.goalId, status: g.status, wake, autoContinue: c?.autoContinue !== false, lease: live ? lease.owner : undefined });

package/dist/agents/pi-sdk.js

@@ -684,6 +684,24 @@ export class PiAgentSession {
         })();
     }
     async prompt(input, options) {
+        // 2026-09-16 (M4 启动硬门禁): 初始化未就绪 → 不执行 Agent。
+        //   fail-closed: 读不出初始化状态也按未就绪处理 (与 runnerResolver"解析不到只诊断"一致)。
+        //   测试环境 (VITEST) 跳过: 那 1800+ 用例跑在隔离 HOME 里, 本来就没有真实配置。
+        if (!process.env.VITEST) {
+            try {
+                const { getSetupGateCached } = await import('../setup/setup-store.js');
+                const { gate, state } = await getSetupGateCached();
+                if (gate !== 'ready') {
+                    const why = `初始化未就绪 (${gate}, 当前阶段 ${state.stage})${state.lastError ? ` — ${state.lastError.message}` : ''}`;
+                    const hint = (state.actions && state.actions[0]) || '运行 `bolloon setup` 完成初始化';
+                    this.messageHistory.push({ role: 'user', content: input });
+                    this.messageHistory.push({ role: 'assistant', content: `[初始化未就绪] ${why}\n${hint}` });
+                    console.warn(`[PiAgent] 拒绝执行: ${why}`);
+                    return `[初始化未就绪] ${why}\n${hint}`;
+                }
+            }
+            catch { /* 门禁自身异常 → 按"不能判定"处理会阻塞一切; 这里只在能读到状态时才拦 */ }
+        }
         this.minimaxAvailable = this.checkMinimax();
         this.currentChannelId = options?.channelId ?? this.currentChannelId;
         // 2026-08-08: 运行轨迹采集 (落盘 + OrbitDB, 失败静默) — 包裹 onStream 收集步骤事件
@@ -1209,6 +1227,8 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
     /** 2026-09-16 (M2): 本次执行是"从 checkpoint 恢复"的 runId (非空 = 恢复模式, 不再新建 run) */
     resumeRunId = '';
     resumePlan = null;
+    /** 2026-09-16 (2-C.4): 外部请求 id (工具层设; 回包必须带上才能精确匹配) */
+    pendingExternalRequestId;
     /** 2026-09-16 (M3): 外部等待中 (awaiting_external) —— 收到成功步骤后回 running */
     awaitingExternal = false;
     /** 2026-09-16 (M3): 熔断原因 (同一工具连续失败达上限 → needs_human) */
@@ -1277,6 +1297,25 @@ ${PiAgentSession.TOOL_SELECTION_GUIDE}
         if (cls === 'external_no_reply') {
             this.awaitingExternal = true;
             await this.safeSetRunStatus(this.currentRunId, 'awaiting_external');
+            // 2026-09-16 (2-C.4): 把"在等什么"写成持久化事实 (来源/关联/过期), 否则真实回包到了也不知道该唤醒谁。
+            try {
+                if (this.currentGoalId) {
+                    const { bindExternalWait, newContinuationId, defaultWaitExpiry } = await import('./external-events.js');
+                    const isDelegate = /delegate/i.test(String(tool || ''));
+                    await bindExternalWait(this.currentGoalId, {
+                        requestId: this.pendingExternalRequestId || `${this.currentRunId}:${Date.now().toString(36)}`,
+                        continuationId: newContinuationId(this.currentGoalId),
+                        expectedSource: isDelegate ? 'delegate' : 'p2p',
+                        expectedEvent: 'result',
+                        createdAt: new Date().toISOString(),
+                        expiresAt: defaultWaitExpiry(Date.now(), Number(process.env.BOLLOON_EXTERNAL_WAIT_MS || 30 * 60_000)),
+                        note: `${isDelegate ? 'delegate 回包' : 'P2P 协作回复'} 等待中 (tool=${tool})`,
+                    });
+                }
+            }
+            catch (e) {
+                await recordDegradation({ kind: 'core', op: 'pi-sdk.bindExternalWait', runId: this.currentRunId, message: String(e?.message || e) }).catch(() => { });
+            }
             return;
         }
         // 鉴权类: 不重试, 直接交人