pi-proactive 0.0.0-stage → 0.2.0-beta.3

package/build/src/trigger.js

@@ -0,0 +1,501 @@
+import { digestOf } from "./lineage.js";
+import { evaluateShallowIdle, isIdleTriggerEnvelope } from "./trust-policy.js";
+/** 注入内容自带来源前缀（custom 消息在 LLM 层会变成 role:"user"，模型无法自行区分来源）。 */
+const SOURCE_PREFIX = "[来自 proactive]";
+/** 本地触发的 customType（跨进程 peer 用 "proactive:peer"，M4 才需要）。 */
+const LOCAL_CUSTOM_TYPE = "proactive:task";
+/** 跨进程 peer 消息的来源标记（与扩展入口的 PEER_CUSTOM_TYPE 同值；src 不反向依赖 extensions）。 */
+const PEER_CUSTOM_TYPE = "proactive:peer";
+/** 入站对端提问的「回信句柄」行前缀（让被问方一眼看出这是一条**待应答**的提问）。 */
+const ASK_HANDLE_PREFIX = "[待应答的对端提问]";
+/**
+ * 注入正文里的**回信句柄**行（规范 §6.5）。
+ *
+ * 为什么必须有：被问方要能拿到**回信所需的 id**（`correlationId` + 线程键），
+ * 并且能分辨「这是一条对端的提问、等着回话」—— 否则它只会被当成普通消息答用户。
+ *
+ * 形态：**一行可读摘要**（不把 id 裸暴露成噪声），且**不要求模型做任何事**——
+ * 回信由**插件代劳**（`src/peer.ts` 的 `PeerResponder` → 回信信封）。
+ *
+ * @returns 句柄行；不是「带关联 id 的提问」时返回 `undefined`（普通消息不加这行）。
+ */
+export function formatAskHandle(msg) {
+    if (!msg || msg.kind !== "ask")
+        return undefined;
+    const correlationId = msg.correlationId;
+    if (correlationId === undefined || correlationId === "")
+        return undefined;
+    const thread = msg.threadId ?? "（无）";
+    return `${ASK_HANDLE_PREFIX} correlationId=${correlationId} · 线程=${thread} · 来自=${msg.from} —— 这是对端的一条待应答提问；你的回答将由插件自动回传给对方（无需调用任何工具）。`;
+}
+/**
+ * 投递触发器：把 Envelope 变成「模型回合」或「用户通知」。
+ *
+ * 语义见 M1 契约 §5，不得偏离：
+ * - intent === "notify" → 只 appendEntry + ctx.ui.notify，不启动回合；
+ * - askUser → 先 ctx.ui.select/input（必须带 { timeout: config.askTimeoutMs }）：
+ *   无 UI → 降级为 notify 并记录「无 UI，未能提问」；
+ *   **用户取消（Esc）→ 不消耗额度、不记 pending（记一条 declined 审计事件）、文案「已取消」**；
+ *   **超时未答 → 消耗额度、记 pending、文案「未在时限内收到回答，已记为待答」**（绝不无限等待）；
+ * - 交给模型时：宿主空闲 → sendMessage(msg, { triggerTurn: true })（不带 deliverAs）；
+ *   宿主忙 → sendMessage(msg, { deliverAs: intent === "interrupt" ? "steer" : "followUp" })。
+ *
+ * **记账点唯一**：护栏 check + record 只在本模块内发生；
+ * 调用方（idle/scheduler）不得自行 check/record（否则 askUser 的回答会被 defer 静默丢弃）。
+ *
+ * **额度记账在「提问有结论之后」**（O-1 裁决的直接后果）：askUser 路径先 check（提问**之前**判定，
+ * 额度不足就不打扰用户）→ 提问 → **拿到结论后**才 record：
+ * 回答 → 记一次（额度消耗）；超时未答 → 记一次（额度消耗）；**用户取消 → 不记（额度长度不变）**。
+ * 拿到回答后**直接投递，不再二次 check** —— 提问窗口内被别处占用的额度不得吞掉用户的回答。
+ *
+ * 为什么记账点后移：「Esc 取消 = 用户明确拒绝 → **不消耗额度**」这条裁决，与「开口即记账」不可兼得
+ * —— 额度账本（`src/guard.ts`）只有 `record()` 追加、没有撤销接口，开口的记账无法收回。
+ * 后移的副作用（提问窗口内本机不再被冷却挡住）由 `openQuestions` 就地补偿：
+ * 提问期间不叠加提问、不叠加本机投递（见 `openQuestions` 字段注释）。
+ *
+ * **回答归因不在本模块**：本模块**不产生任何回信**（不构造回信类信封），
+ * 也**不按「下一条 assistant 文本」做 FIFO 归因** —— 归因的唯一真源是
+ * `src/peer.ts` 的 `PeerResponder`（pending 队列 + `ambiguous` 降级）。
+ *
+ * 所有对外调用整体 try/catch：宿主 uncaughtException → process.exit(1)，异常不得冒泡。
+ */
+export class Trigger {
+    deps;
+    /** 未获回答的提问（记 pending，便于后续补问；仅本进程内存）。 */
+    pending = [];
+    /** 正在等待用户回答的提问数（提问期间本机不再叠加打扰）。 */
+    openQuestions = 0;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    /**
+     * 把一条消息投递给模型（或降级为用户通知），并返回**最终**投递结果。
+     *
+     * **只有一个结果源**（契约 §5）：返回值即最终结果，调用方**必须 await 之后**再决策。
+     * 没有「结果回调」这条第二轨（回调通道已删除）—— 双轨必然漂移（提问前的 "notified" 会让调用方把
+     * 「回答被护栏 defer」误判成「已执行」→ 用户的回答被静默丢弃）。
+     *
+     * 返回值语义：
+     * - `intent === "notify"` → "notified"（零 token，未占额度）
+     * - `opts.askUser === true` → **await 到用户回答之后**才 resolve：
+     *   回答后真的投递 → "delivered"；**提问之前**额度不足（defer/drop）→ 不提问 → "deferred"/"dropped"；
+     *   无 UI → 降级 notify → "notified"；超时未答 → 记 pending + notify → "notified"；
+     *   用户取消（Esc）→ 不记 pending + notify「已取消」→ "notified"；异常 → "failed"。
+     * - 其余路径 → 本次投递结果。
+     */
+    async deliverToModel(msg, intent, opts) {
+        const cause = resolveCause(msg, opts?.cause);
+        try {
+            // **触发原因落盘（因）**：判定通过、决定触发的那一刻就把 cause + 判定依据写进事件流。
+            this.noteTriggered(msg, cause);
+            // **空闲浅层闸门**（卡 D2）：空闲触发默认静默 —— 没有用户交代、或分数不足 → 不开口。
+            // 缺省未注入 `trustPolicy` → 闸门不生效（既有行为逐字不变）。
+            const shallow = this.evaluateShallow(msg, cause);
+            if (shallow !== undefined && !shallow.speak) {
+                this.noteDropped(msg, cause, shallow.reason);
+                return "dropped";
+            }
+            if (intent === "notify") {
+                this.notifyOnly(msg.subject ?? "proactive", msg.body, msg);
+                this.noteDelivery(msg, cause, "notified");
+                return "notified";
+            }
+            if (opts?.askUser === true) {
+                if (!this.deps.ctx.hasUI) {
+                    // 无 UI（json/print 模式）→ 降级为 notify，并记录「无 UI，未能提问」
+                    console.warn("[proactive] 无 UI，未能提问");
+                    this.notifyOnly(msg.subject ?? "proactive", `${msg.body}（无 UI，未能提问）`, msg);
+                    this.noteDelivery(msg, cause, "notified");
+                    return "notified";
+                }
+                // 提问是异步的 → 最终结果只能在 await 之后拿到。
+                return await this.askThenDeliver(msg, intent, opts.inboundPeer === true, cause);
+            }
+            return this.deliverToModelNow(msg, intent, cause, undefined, { skipGuard: opts?.inboundPeer === true });
+        }
+        catch (err) {
+            console.error("[proactive] deliverToModel 失败", err);
+            // 内层路径各自已记「失败」；这里只兜底异常冒泡（不重复记账）。
+            return "failed";
+        }
+    }
+    /** 只通知用户，不打扰模型（零 token）。 */
+    notify(title, message) {
+        this.notifyOnly(title, message);
+    }
+    // ---- 内部实现 ----
+    /** 用户通知路径：appendEntry（审计/落转录）+ ui.notify，绝不启动回合。 */
+    notifyOnly(title, message, msg) {
+        try {
+            this.deps.pi.appendEntry(LOCAL_CUSTOM_TYPE, {
+                kind: "notify",
+                title,
+                message,
+                agentId: this.deps.agentId,
+                envelopeId: msg?.id,
+                at: Date.now(),
+            });
+            this.deps.ctx.ui.notify(title ? `${title}: ${message}` : message);
+        }
+        catch (err) {
+            console.error("[proactive] notify 失败", err);
+        }
+    }
+    /**
+     * 空闲浅层判定（卡 D2）：**不是**空闲触发、或未注入策略 → 返回 undefined（闸门不生效）。
+     *
+     * 分量的来源（可复核）：
+     * - 价值 = `已空闲时长 / 空闲阈值`（有判定依据时）——缺依据时按 1 计（已由上游判定为可触发）；
+     * - 紧急度 = 1（空闲 = 用户不在场）；
+     * - 打断代价 = 1（浅层判定发生在护栏记账之前，此处不重复计费）。
+     */
+    evaluateShallow(msg, cause) {
+        const policy = this.deps.trustPolicy;
+        if (policy === undefined || policy.enabled === false)
+            return undefined;
+        if (!isIdleTriggerEnvelope(msg) && cause.type !== "idle")
+            return undefined;
+        const basis = cause.basis;
+        const hasRatio = basis?.idleForMs !== undefined && basis.thresholdMs !== undefined && basis.thresholdMs > 0;
+        const value = hasRatio ? (basis?.idleForMs ?? 0) / (basis?.thresholdMs ?? 1) : 1;
+        let backed = false;
+        try {
+            backed = this.deps.hasUserBacking?.() === true;
+        }
+        catch (err) {
+            console.error("[proactive] 是否有用户交代判定失败（按没有交代处理）", err);
+        }
+        return evaluateShallowIdle({
+            policy,
+            value,
+            valueSource: hasRatio ? "trust-policy: idleForMs/thresholdMs" : "trust-policy: default",
+            urgency: 1,
+            urgencySource: "trust-policy: idle",
+            interruptionCost: 1,
+            interruptionCostSource: "trust-policy: default",
+            backedByUserRequest: backed,
+        });
+    }
+    /**
+     * 向用户提问，并把结局分成**回答 / 用户取消（Esc）/ 超时未答**三种。
+     *
+     * **为什么必须自己计时**：宿主对「Esc 取消」与「超时」**都** resolve(undefined)
+     * （宿主源码 `dist/modes/interactive/components/extension-selector.js`：倒计时到期与取消键
+     * 走同一个 `onCancelCallback`；RPC 模式同样都归一到 undefined）→ **插件侧无法从返回值区分**。
+     * 因此这里自建**时限闸门**：闸门先到 → 「超时未答」；宿主在时限内先收场（空值）→ 「用户取消」。
+     *
+     * 闸门同时通过 `AbortSignal` 收起宿主对话框（宿主支持 `opts.signal`），
+     * 保证「时限到了」时对话框立刻消失，而不是等宿主自己的倒计时收尾。
+     */
+    async ask(msg) {
+        const question = msg.subject ?? msg.body;
+        const rawOptions = msg.options;
+        const options = Array.isArray(rawOptions) ? rawOptions : undefined;
+        const timeoutMs = this.deps.config.askTimeoutMs;
+        const controller = new AbortController();
+        // 绝对到期时刻：宿主自己的超时计时器在**我们之后**才启动 → 它的到期时刻必然 ≥ 本值。
+        const deadlineAt = Date.now() + timeoutMs;
+        let timer;
+        // 兜底闸门：万一宿主不兑现 timeout（不该发生），到点我们自己收场（并收起对话框）。
+        const deadline = new Promise((resolve) => {
+            timer = setTimeout(() => {
+                resolve({ status: "timeout" });
+                controller.abort();
+            }, timeoutMs);
+            // 兜底闸门**不拖住进程退出**（unref）：它只在「宿主不兑现 timeout」时兜底，
+            // 宿主进程本来就长期存活（stdin 等句柄在），到期照样会触发 → 对话框被 abort 收起。
+            // 且它在 finally 里被 clearTimeout → 正常路径零残留（不留孤儿定时器）。
+            timer.unref?.();
+        });
+        try {
+            const dialog = options && options.length > 0
+                ? this.deps.ctx.ui.select(question, options, { timeout: timeoutMs, signal: controller.signal })
+                : this.deps.ctx.ui.input(question, msg.body, { timeout: timeoutMs, signal: controller.signal });
+            // 宿主 reject（抛错）也要被吸收：闸门先赢时，宿主随后的 reject 不能变成 unhandledRejection。
+            const settled = await Promise.race([
+                dialog.then((value) => ({ status: "value", value }), (error) => ({ status: "error", error })),
+                deadline,
+            ]);
+            if (settled.status === "error")
+                throw settled.error;
+            if (settled.status === "timeout")
+                return { status: "timeout" };
+            const value = settled.value;
+            if (value === undefined || value === null || value === "") {
+                // 宿主交回空值 —— 它对「Esc 取消」与「超时」都这么干（见上）→ 用**是否已到期**区分：
+                // 宿主的超时计时器在**我们之后**才启动 → 它的到期时刻必然 ≥ 我们的到期时刻；
+                // 于是「已到期」= 超时未答，「未到期」= 用户主动取消（Esc）。
+                return Date.now() >= deadlineAt ? { status: "timeout" } : { status: "cancelled" };
+            }
+            return { status: "answered", answer: String(value) };
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    /**
+     * askUser 路径：**先判额度（提问之前）→ 提问 → 按结论记账 → 回答则直接投递**。
+     *
+     * 契约（V-02 修复 + O-1 裁决）：
+     * - 无 UI → 降级 notify（不消耗额度）→ "notified"；
+     * - `guard.check(now)` → `defer` → **不提问**、返回 "deferred"（不消耗）；`drop` → "dropped"（不消耗）；
+     * - **用户取消（Esc）** → **不消耗额度**、**不记 pending**（记一条 `declined` 审计事件）、文案「已取消」→「notified」；
+     * - **超时未答** → 消耗额度、记 pending、文案「未在时限内收到回答，已记为待答」→「notified"；
+     * - 有回答 → 消耗额度 → **直接投递**（不再二次 check）→「delivered」。
+     *
+     * 理由（V-02 真实宿主冒烟 Blocker-1）：提问窗口内若发生另一次主动投递，占用的额度不得把
+     * **已获得的用户回答** defer 掉（否则用户的回答被静默丢弃且永久丢失）。
+     *
+     * 备注：投递失败（异常）时额度已消耗 —— 属可接受（我们确实已经打扰了用户）。
+     */
+    async askThenDeliver(msg, intent, inboundPeer, cause) {
+        try {
+            const now = Date.now();
+            // ⓪ 提问期间不再叠加提问（等价于旧「开口即记账」带来的冷却效果，见类注释）。
+            if (!inboundPeer && this.openQuestions > 0) {
+                console.warn("[proactive] 已有提问在等待回答，本次不叠加提问");
+                this.noteDropped(msg, cause, "defer");
+                return "deferred";
+            }
+            // ① 开口之前先判定额度：额度不足就**不打扰**用户（也不消耗额度）。
+            //    入站 peer 协作消息**不受**本机主动触发的频率闸门约束（见 DeliverOptions.inboundPeer）。
+            if (!inboundPeer) {
+                const verdict = this.deps.guard.check(now);
+                if (verdict !== "allow") {
+                    console.warn(`[proactive] 护栏判定 ${verdict}，本次不提问`);
+                    this.noteDropped(msg, cause, verdict);
+                    return verdict === "defer" ? "deferred" : "dropped";
+                }
+            }
+            // ② 提问（带 timeout + 自建时限闸门 → 能区分「取消」与「超时」）。
+            this.openQuestions++;
+            let asked;
+            try {
+                asked = await this.ask(msg);
+            }
+            finally {
+                this.openQuestions--;
+            }
+            if (asked.status === "cancelled") {
+                // 用户明确拒绝 → **不消耗额度**、**不记 pending**（只留一条 declined 审计事件）。
+                console.warn("[proactive] 用户取消提问（已取消）：不消耗额度、不记待答");
+                this.recordDeclined(msg);
+                this.notifyOnly(msg.subject ?? "proactive", `${msg.body}（已取消）`, msg);
+                this.noteDelivery(msg, cause, "notified");
+                return "notified";
+            }
+            // ③ 用户确实被问过（回答或超时未答）→ 额度在此刻消耗（一次）。
+            if (!inboundPeer)
+                this.deps.guard.record(Date.now());
+            if (asked.status === "timeout") {
+                console.warn("[proactive] 提问未获回答，记为 pending");
+                this.recordPending(msg);
+                this.notifyOnly(msg.subject ?? "proactive", `${msg.body}（未在时限内收到回答，已记为待答）`, msg);
+                this.noteDelivery(msg, cause, "notified");
+                return "notified";
+            }
+            // ④ 拿到回答 → 直接投递（不再二次 check：额度已记，提问窗口内被别处占用的额度不得吞掉用户的回答）。
+            return this.deliverToModelNow(msg, intent, cause, asked.answer, { skipGuard: true });
+        }
+        catch (err) {
+            console.error("[proactive] askUser 失败", err);
+            this.noteDelivery(msg, cause, "failed", "exception");
+            return "failed";
+        }
+    }
+    recordPending(msg) {
+        const question = msg.subject ?? msg.body;
+        this.pending.push({ question, envelopeId: msg.id, at: Date.now() });
+        try {
+            this.deps.pi.appendEntry(LOCAL_CUSTOM_TYPE, {
+                stage: "pending",
+                question,
+                envelopeId: msg.id,
+                agentId: this.deps.agentId,
+                at: Date.now(),
+            });
+        }
+        catch (err) {
+            console.error("[proactive] recordPending 失败", err);
+        }
+    }
+    /**
+     * 用户**主动取消**（Esc）的审计事件：只留痕，不记待答、不消耗额度。
+     *
+     * 用 `stage:"declined"`（**不用** `kind`）—— 与 `stage:"pending"` / `stage:"deliver"` 同族，
+     * 避免与宿主自定义消息的 `kind` 字段撞名（历史缺陷：kind 同时被用作消息类型与记录判别键）。
+     */
+    recordDeclined(msg) {
+        const question = msg.subject ?? msg.body;
+        try {
+            this.deps.pi.appendEntry(LOCAL_CUSTOM_TYPE, {
+                stage: "declined",
+                message: "已取消",
+                question,
+                envelopeId: msg.id,
+                agentId: this.deps.agentId,
+                at: Date.now(),
+            });
+        }
+        catch (err) {
+            console.error("[proactive] recordDeclined 失败", err);
+        }
+    }
+    /**
+     * 交给模型：空闲 → 启动新回合；忙 → steer/followUp 插入当前回合。
+     * 护栏统一在此把守（护栏计数作用域 = 每 agent）；notify 不占额度（零 token，不启动回合）。
+     *
+     * **记账点唯一**：check 通过 → appendEntry → record → sendMessage，全部只在这里发生；
+     * 调用方不得自行 check/record（否则 askUser 路径的回答会被 defer 静默丢弃）。
+     *
+     * `skipGuard`：**额度已在 askUser 路径记过**（回答/超时）或**本就是入站协作**（不消耗本机额度）
+     * → 投递时既不再 check 也不再 record。
+     */
+    deliverToModelNow(msg, intent, cause, answer, opts) {
+        const now = Date.now();
+        const skipGuard = opts?.skipGuard === true;
+        try {
+            if (!skipGuard) {
+                // 提问期间不再叠加本机投递（等价于旧「开口即记账」带来的冷却效果，见类注释）。
+                if (this.openQuestions > 0) {
+                    console.warn("[proactive] 已有提问在等待回答，本次不叠加投递");
+                    this.noteDropped(msg, cause, "defer");
+                    return "deferred";
+                }
+                const verdict = this.deps.guard.check(now);
+                if (verdict !== "allow") {
+                    console.warn(`[proactive] 护栏判定 ${verdict}，本次不投递`);
+                    this.noteDropped(msg, cause, verdict);
+                    return verdict === "defer" ? "deferred" : "dropped";
+                }
+            }
+            this.deps.pi.appendEntry(LOCAL_CUSTOM_TYPE, {
+                stage: "deliver",
+                envelopeId: msg.id,
+                from: msg.from,
+                to: msg.to,
+                subject: msg.subject,
+                intent,
+                answer,
+                agentId: this.deps.agentId,
+                at: Date.now(),
+            });
+            // 记账点唯一：check 已通过 → 在真正投递前记账（调用方不得自行 record）。
+            // skipGuard 时额度已在 askUser 路径记过（回答/超时），或本就是入站协作（不消耗本机额度）。
+            if (!skipGuard)
+                this.deps.guard.record(now);
+            // 来源标记：跨进程 peer 消息用 `msg.customType`（"proactive:peer"），
+            // 本地触发仍用 LOCAL_CUSTOM_TYPE —— 模型据此区分消息来源。
+            const custom = {
+                customType: msg.customType ?? LOCAL_CUSTOM_TYPE,
+                content: this.buildContent(msg, answer),
+                display: true,
+            };
+            if (this.deps.ctx.isIdle()) {
+                // 空闲：带 triggerTurn 启动新回合（不带 deliverAs —— 空闲时 deliverAs 不生效）
+                this.deps.pi.sendMessage(custom, { triggerTurn: true });
+            }
+            else {
+                // 忙（streaming）：deliverAs 仅在 streaming 生效
+                this.deps.pi.sendMessage(custom, {
+                    deliverAs: intent === "interrupt" ? "steer" : "followUp",
+                });
+            }
+            // 投递确实发生（模型接手）→ 记「果」的起点：事件流据此开判定窗口。
+            this.noteDelivery(msg, cause, "delivered");
+            return "delivered";
+        }
+        catch (err) {
+            console.error("[proactive] deliverToModelNow 失败", err);
+            this.noteDelivery(msg, cause, "failed", "exception");
+            return "failed";
+        }
+    }
+    // ---- 血缘（事件流）接线 ----
+    /**
+     * 记一次「触发」（因）：cause + 判定依据 + 正文**长度/摘要**（**不含正文**）。
+     *
+     * 事件流写失败**不得**影响投递语义（宿主 uncaughtException → process.exit(1)）。
+     */
+    noteTriggered(msg, cause) {
+        try {
+            const body = typeof msg.body === "string" ? msg.body : "";
+            this.deps.lineage?.noteTriggered({
+                cause: cause.type,
+                envelopeId: msg.id,
+                ...(cause.basis !== undefined ? { basis: cause.basis } : {}),
+                ...(cause.peer !== undefined ? { peer: cause.peer } : {}),
+                ...(cause.taskId !== undefined ? { taskId: cause.taskId } : {}),
+                bodyLen: body.length,
+                bodyDigest: digestOf(body),
+            });
+        }
+        catch (err) {
+            console.error("[proactive] 记事件流失败", err);
+        }
+    }
+    /**
+     * 记一次「投递完成」；投递成功时回调 `onDelivered`（供派生任务绑定 `triggeredBy`）。
+     */
+    noteDelivery(msg, cause, result, reason) {
+        try {
+            const event = this.deps.lineage?.noteDelivery({
+                cause: cause.type,
+                result,
+                envelopeId: msg.id,
+                ...(cause.basis !== undefined ? { basis: cause.basis } : {}),
+                ...(cause.peer !== undefined ? { peer: cause.peer } : {}),
+                ...(cause.taskId !== undefined ? { taskId: cause.taskId } : {}),
+                ...(reason !== undefined ? { reason } : {}),
+            });
+            if (result === "delivered" && event !== undefined) {
+                try {
+                    this.deps.onDelivered?.({ envelopeId: msg.id, eventId: event.id, cause: cause.type, ts: event.ts });
+                }
+                catch (err) {
+                    console.error("[proactive] onDelivered 回调失败", err);
+                }
+            }
+        }
+        catch (err) {
+            console.error("[proactive] 记事件流失败", err);
+        }
+    }
+    /** 记一次「被拦下」（护栏 / 前置条件）：带原因。 */
+    noteDropped(msg, cause, reason) {
+        try {
+            this.deps.lineage?.noteDropped({
+                cause: cause.type,
+                reason,
+                envelopeId: msg.id,
+                ...(cause.basis !== undefined ? { basis: cause.basis } : {}),
+                ...(cause.peer !== undefined ? { peer: cause.peer } : {}),
+                ...(cause.taskId !== undefined ? { taskId: cause.taskId } : {}),
+            });
+        }
+        catch (err) {
+            console.error("[proactive] 记事件流失败", err);
+        }
+    }
+    /** 注入内容自带来源前缀（调用方传裸 body，避免双前缀）。 */
+    buildContent(msg, answer) {
+        const body = msg.body.startsWith(SOURCE_PREFIX) ? msg.body : `${SOURCE_PREFIX} ${msg.body}`;
+        const handle = formatAskHandle(msg);
+        const content = handle === undefined ? body : `${body}\n${handle}`;
+        return answer === undefined ? content : `${content}\n[用户回答] ${answer}`;
+    }
+}
+/**
+ * 触发原因（缺省时按信封来源**推断**）。
+ *
+ * 推断只是兜底：`customType === "proactive:peer"` 的入站协作消息 → peer-request，
+ * 其余 → manual。真实调用方（扩展入口）应当显式给出 cause 与判定依据。
+ */
+function resolveCause(msg, cause) {
+    if (cause !== undefined)
+        return cause;
+    if (msg.customType === PEER_CUSTOM_TYPE)
+        return { type: "peer-request" };
+    return { type: "manual" };
+}