pi-proactive 0.2.0-beta.2 → 0.2.0-beta.3

package/build/src/progress-eta.js

@@ -0,0 +1,134 @@
+/**
+ * 进度与 ETA 的**唯一接线点**（任务卡 ETA · E1）。
+ *
+ * 口径来源：`scripts/progress-clock.py`（**项目进度时钟**）——本模块**不另写一套 ETA 算法**，
+ * 只做三件事：
+ *   ① 调用时钟的只读 ETA 模式（`--eta --json-only`：不写历史账本、不跑门禁/测试）；
+ *   ② 解析时钟输出的 ETA 契约（区间 + 置信度 + 归因 + 阻塞项）；
+ *   ③ 把**同一份正文**交给人侧命令与 AI 侧工具 → 两侧逐字一致（A3）。
+ *
+ * 为什么有 30s 缓存：时钟读数带时间戳；人侧命令与 AI 工具若各跑一次时钟，两侧文字会差一个
+ * 时间戳 → 「同源同口径」被时间戳破坏。缓存让两侧拿到**同一份快照**（30s 内的读数本身
+ * 也不会变）。缓存**不写**任何状态（只读）。
+ */
+import { execFile } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const CACHE_TTL_MS = 30_000;
+let cached = null;
+/** 向上找仓库根（判据：存在 `scripts/progress-clock.py`）。找不到 → null。 */
+export function findClockScript(startDir) {
+    let dir = startDir;
+    for (let i = 0; i < 8; i += 1) {
+        const candidate = path.join(dir, "scripts", "progress-clock.py");
+        if (fs.existsSync(candidate))
+            return candidate;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/** 仓库根（时钟脚本所在目录的上一级）。 */
+function findRepoRoot(startDir) {
+    const script = findClockScript(startDir);
+    return script === null ? null : path.dirname(path.dirname(script));
+}
+function runClock(script, repoRoot, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        execFile("python3", [script, "--eta", "--json-only"], { cwd: repoRoot, timeout: timeoutMs, maxBuffer: 8 * 1024 * 1024 }, (err, stdout, stderr) => {
+            // 退出码 1 = 时钟有告警（UNATTRIBUTED / NOT_CONVERGING …）→ **不是失败**，读数仍有效；
+            // 退出码 2 = 时钟自身出错（数据不可解析）→ 必须报错，不得拿半截输出当 ETA。
+            const out = String(stdout);
+            if (err) {
+                const code = err.code;
+                if (code === 1 && out.trim() !== "") {
+                    resolve(out);
+                    return;
+                }
+                const detail = String(stderr || err.message || "").trim();
+                reject(new Error(detail === "" ? err.message : detail));
+                return;
+            }
+            resolve(out);
+        });
+    });
+}
+/**
+ * 读一次进度与 ETA。
+ *
+ * @param opts.repoRoot 覆盖仓库根（测试用）；默认从**模块自身位置**向上找
+ *        （不能用 cwd：扩展装在用户机器上时 cwd 与本仓库无关）。
+ */
+export async function readProgressEta(opts = {}) {
+    const now = Date.now();
+    if (!opts.fresh && cached !== null && now - cached.at < CACHE_TTL_MS) {
+        return cached.result;
+    }
+    const timeoutMs = opts.timeoutMs ?? 60_000;
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const repoRoot = opts.repoRoot ?? process.env.PROGRESS_CLOCK_REPO ?? findRepoRoot(here);
+    if (repoRoot === null) {
+        const msg = "proactive: 进度时钟不可用 —— 找不到 scripts/progress-clock.py" +
+            "（ETA 只在源码仓库内可算；安装后的扩展包不含仓库状态）";
+        const result = {
+            ok: false,
+            text: msg,
+            details: { ok: false, source: "progress-clock", error: msg },
+        };
+        cached = { at: now, result };
+        return result;
+    }
+    const script = path.join(repoRoot, "scripts", "progress-clock.py");
+    try {
+        const stdout = await runClock(script, repoRoot, timeoutMs);
+        const payload = JSON.parse(stdout.trim());
+        const contract = payload.eta_contract;
+        if (contract === undefined) {
+            throw new Error("时钟输出里没有 eta_contract 字段（口径不一致 → 拒绝给出 ETA）");
+        }
+        const result = {
+            ok: true,
+            text: contract.report,
+            details: {
+                ok: true,
+                range_low_hours: contract.range_low_hours,
+                range_high_hours: contract.range_high_hours,
+                confidence: contract.confidence,
+                confidence_basis: contract.confidence_basis,
+                blockers: (contract.blockers ?? []).map((b) => ({
+                    source: String(b["source"] ?? ""),
+                    blockKind: String(b["kind"] ?? ""),
+                    hours: Number(b["hours"] ?? 0),
+                    reason: String(b["reason"] ?? ""),
+                    ...(b["from"] === undefined ? {} : { from: String(b["from"]) }),
+                    ...(b["to"] === undefined ? {} : { to: String(b["to"]) }),
+                    disposition: String(b["disposition"] ?? ""),
+                    widens: b["widens"] === true,
+                })),
+                attribution: contract.attribution,
+                layer3_hours: contract.layer3_hours,
+                widening_hours: contract.widening_hours,
+                source: "scripts/progress-clock.py",
+            },
+        };
+        cached = { at: now, result };
+        return result;
+    }
+    catch (err) {
+        const msg = `proactive: 进度时钟读取失败：${err instanceof Error ? err.message : String(err)}`;
+        const result = {
+            ok: false,
+            text: msg,
+            details: { ok: false, source: "scripts/progress-clock.py", error: msg },
+        };
+        cached = { at: now, result };
+        return result;
+    }
+}
+/** 测试用：清掉缓存（避免用例之间互相污染）。 */
+export function resetProgressEtaCache() {
+    cached = null;
+}

package/build/src/trigger.js

@@ -1,4 +1,5 @@
 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 才需要）。 */
@@ -87,6 +88,13 @@ export class Trigger {
         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");
@@ -133,6 +141,41 @@ export class Trigger {
             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）/ 超时未答**三种。
      *

package/build/src/trust-loop.js

@@ -0,0 +1,321 @@
+/**
+ * 目标驱动与自主推进的**执行环**（卡 D6 / D7）+ 人机分工（卡 D3）。
+ *
+ * 同一套循环，三档自主度（`docs/product/agentic-loop.md` §1）：
+ * ```
+ * 目标 → 候选行动 → 打分(DECIDE1) → 执行 → 结账(带归因) → 回灌目标进度
+ * 自主档位：L-B 托付（条件由用户给） / L-C 目标驱动（条件由 AI 推导）
+ *          / L-D 自主推进（目标由 AI 从账本的未竟事项里发现）
+ * ```
+ *
+ * **六条必要前提**（缺一即不得进入自主推进，`docs/product/agentic-loop.md` §2）：
+ * ```
+ * ① 目标可判定  ② 预算硬上限  ③ 权限阶梯
+ * ④ 可中止可撤销 ⑤ 可追溯      ⑥ 不越界（范围外显式请求授权）
+ * ```
+ *
+ * 红线（§6）：
+ * - 不得替人做**需要担责**的决定 → 不可逆 / 对外 / 价值取舍 → 一律 **human-gated**；
+ * - 不得**假装完成** → 未达成的目标必须显式产出「未达成 / 需人决策」记录，**不得静默结账**；
+ * - 不得在目标外动手 → 范围外 → 产出**显式请求授权**的记录（不是自动执行）。
+ *
+ * @capability: trust-loop
+ * @observable: pi-proactive/src/trust-loop.ts:advanceCandidate
+ * @attribution: pi-proactive/src/trust-loop.ts:advanceCandidate
+ * @outcome: pi-proactive/src/trust-metrics.ts:TrustMetrics
+ * @checked: test:pi-proactive/tests/trust-loop.test.ts#D6-3 执行 → 结账带归因
+ */
+import { scoreDecision } from "./idle.js";
+import { goalGap, goalSatisfied, isDecidable, } from "./trust-registry.js";
+/**
+ * 权限阶梯（护栏③）：**人的经历有效** → 需要担责的决定必须回到人手里。
+ *
+ * - `read` / `write`（可撤销）→ AI 可自主做；
+ * - `external`（对外承诺）/ `irreversible`（不可逆）/ `value-judgment`（取舍与价值排序）
+ *   → **human-gated**：只能生成待人决策的记录，**不得自动执行**。
+ */
+export function resolvePermissionTier(actionType) {
+    switch (actionType) {
+        case "read":
+            return "auto";
+        case "write":
+            return "limited";
+        default:
+            return "human-gated";
+    }
+}
+/** 六条护栏（缺一即不得进入自主推进）。 */
+export const GUARDRAILS = [
+    "goal-decidable",
+    "budget-cap",
+    "permission-ladder",
+    "abortable-revocable",
+    "traceable",
+    "in-scope",
+];
+/**
+ * 六条护栏的判定（纯函数）。
+ *
+ * @param budgetAvailable 预算是否还有余额（由调用方用登记册的预算账本判定）。
+ */
+export function checkGuardrails(goal, candidate, budgetAvailable) {
+    const violations = [];
+    if (!isDecidable(goal))
+        violations.push({ rule: "goal-decidable", detail: "目标缺可判定的完成定义" });
+    if (!budgetAvailable || goal.budget.maxActions <= goal.budget.usedActions) {
+        violations.push({ rule: "budget-cap", detail: `预算已用尽（${goal.budget.usedActions}/${goal.budget.maxActions}）` });
+    }
+    const expected = resolvePermissionTier(candidate.actionType);
+    if (candidate.permission !== expected) {
+        violations.push({ rule: "permission-ladder", detail: `权限档与动作种类不符（${candidate.permission} ≠ ${expected}）` });
+    }
+    if (goal.permission === "human-gated" && candidate.permission !== "human-gated") {
+        violations.push({ rule: "permission-ladder", detail: "目标整体要求 human-gated" });
+    }
+    if (!candidate.reversible && candidate.permission !== "human-gated") {
+        violations.push({ rule: "abortable-revocable", detail: "不可撤销的动作不得自主执行" });
+    }
+    if (candidate.reason.trim() === "" || candidate.goalId === "") {
+        violations.push({ rule: "traceable", detail: "缺归因（为什么做 / 让哪个目标更近）" });
+    }
+    if (goal.scope.length > 0 && !goal.scope.includes(candidate.scope)) {
+        violations.push({ rule: "in-scope", detail: `范围外（${candidate.scope} ∉ ${goal.scope.join("/")}）` });
+    }
+    return { ok: violations.length === 0, violations };
+}
+/**
+ * 由**目标差距**推导候选行动（卡 D6 的「候选」步）。
+ *
+ * - 完成定义缺失 → **没有候选**（不可判定的目标不许推进）；
+ * - 清单型 → 每个未完成项一个候选；指标型 → 一个候选（把指标推向目标值）。
+ */
+export function deriveCandidates(goal, opts = {}) {
+    if (!isDecidable(goal))
+        return [];
+    const threshold = opts.threshold ?? 1;
+    const observeRatio = opts.observeRatio ?? 0.5;
+    const actionType = opts.actionType ?? "write";
+    const gap = goalGap(goal);
+    const scope = goal.scope[0] ?? goal.id;
+    const value = gap.ratio;
+    const urgency = 1;
+    const interruptionCost = 1;
+    const scoring = scoreDecision({
+        value: { score: value, source: "trust-loop: goalGap.ratio" },
+        urgency: { score: urgency, source: "trust-loop: goal.open" },
+        interruptionCost: { score: interruptionCost, source: "trust-loop: default" },
+    }, threshold, observeRatio);
+    const base = {
+        goalId: goal.id,
+        actionType,
+        permission: resolvePermissionTier(actionType),
+        scope,
+        reversible: true,
+        value,
+        valueSource: "trust-loop: goalGap.ratio",
+        urgency,
+        urgencySource: "trust-loop: goal.open",
+        interruptionCost,
+        interruptionCostSource: "trust-loop: default",
+        score: scoring.score,
+        band: scoring.band,
+    };
+    if (goal.doneWhen?.type === "checklist") {
+        return goal.doneWhen.items
+            .filter((i) => !i.done)
+            .map((item) => ({
+            ...base,
+            id: `${goal.id}#${item.id}`,
+            action: item.text,
+            reason: `目标「${goal.title}」尚差：${item.text}（差距 ${gap.remaining}/${gap.total}）`,
+        }));
+    }
+    const metric = goal.doneWhen;
+    return [
+        {
+            ...base,
+            id: `${goal.id}#metric`,
+            action: `${metric.name} → ${metric.op} ${metric.target}`,
+            reason: `目标「${goal.title}」的 ${metric.name} 当前 ${metric.current}，目标 ${metric.op} ${metric.target}`,
+        },
+    ];
+}
+/**
+ * 推进一个候选行动（卡 D6 的「执行 → 结账」，卡 D7 的护栏）。
+ *
+ * 判定顺序（**顺序本身就是语义**）：
+ * 1. 目标不存在 → failed（不静默）；
+ * 2. 六条护栏 → 有违规 → blocked（**显式记录**，不执行）；
+ * 3. 权限档 = human-gated → human-gated（**不执行、不结账**，产出待人决策记录）；
+ * 4. 消耗预算（硬上限）→ 不足 → blocked；
+ * 5. 执行 → 失败 → failed（**不静默结账**）；
+ * 6. 成功 → 结账：写归因（让哪个目标前进了多少）→ 回灌进度；
+ *    目标仍**未达成** → 显式产出「未达成」记录（**不得静默结账**）。
+ */
+export async function advanceCandidate(deps, candidate) {
+    if (candidate.entrustmentId !== undefined) {
+        // 托付路径：自主推进发现的「未闭合待办」→ 走托付的知会/结账流程。
+        const e = deps.registry.getEntrustment(candidate.entrustmentId);
+        if (e === undefined) {
+            deps.lineage?.noteTrust({ stage: "blocked", entrustmentId: candidate.entrustmentId, reason: "entrustment-not-found" });
+            return { result: "failed", candidate, reason: "托付不存在" };
+        }
+        if (e.needsHuman === true) {
+            const reason = e.humanReason ?? "需要人决定";
+            deps.registry.markNeedsHuman(e.id, reason);
+            deps.lineage?.noteTrust({ stage: "human-gated", entrustmentId: e.id, goalId: e.goalId, reason });
+            return { result: "human-gated", candidate, reason };
+        }
+        if (e.status !== "arrived" && e.status !== "notified") {
+            const reason = `托付尚未到达（${e.status}）→ 不结账`;
+            deps.lineage?.noteTrust({ stage: "blocked", entrustmentId: e.id, goalId: e.goalId, reason });
+            return { result: "blocked", candidate, violations: [{ rule: "goal-decidable", detail: reason }] };
+        }
+        const closed = closeEntrustment(deps, e.id);
+        if (closed.result === "human-gated") {
+            return { result: "human-gated", candidate, reason: closed.reason ?? "需人决定" };
+        }
+        return { result: "settled", candidate, attribution: { goalId: e.goalId ?? "", progressDelta: 1 } };
+    }
+    const goal = deps.registry.getGoal(candidate.goalId);
+    if (goal === undefined) {
+        deps.lineage?.noteTrust({ stage: "blocked", goalId: candidate.goalId, reason: "goal-not-found" });
+        return { result: "failed", candidate, reason: "目标不存在" };
+    }
+    const budgetAvailable = goal.budget.usedActions < goal.budget.maxActions;
+    const report = checkGuardrails(goal, candidate, budgetAvailable);
+    if (!report.ok) {
+        const detail = report.violations.map((v) => `${v.rule}:${v.detail}`).join("；");
+        deps.lineage?.noteTrust({ stage: "blocked", goalId: goal.id, reason: detail });
+        // 范围外 / 不可判定 → 显式请求授权或人决策（**不是**自动执行）。
+        if (report.violations.some((v) => v.rule === "in-scope" || v.rule === "goal-decidable")) {
+            deps.registry.setGoalStatus(goal.id, "needs-human", `需要人授权或补充定义：${detail}`);
+        }
+        return { result: "blocked", candidate, violations: report.violations };
+    }
+    if (candidate.permission === "human-gated") {
+        const reason = `该动作需人担责（${candidate.actionType}）→ 不自动执行`;
+        deps.registry.setGoalStatus(goal.id, "needs-human", reason);
+        deps.lineage?.noteTrust({ stage: "human-gated", goalId: goal.id, reason });
+        return { result: "human-gated", candidate, reason };
+    }
+    if (!deps.registry.consumeBudget(goal.id)) {
+        const detail = `预算硬上限已到（${goal.budget.usedActions}/${goal.budget.maxActions}）`;
+        deps.lineage?.noteTrust({ stage: "blocked", goalId: goal.id, reason: detail });
+        return { result: "blocked", candidate, violations: [{ rule: "budget-cap", detail }] };
+    }
+    let result;
+    try {
+        result = deps.execute !== undefined ? await deps.execute(candidate) : { ok: true, progressDelta: 1 };
+    }
+    catch (err) {
+        const reason = `执行异常：${err instanceof Error ? err.message : String(err)}`;
+        deps.lineage?.noteTrust({ stage: "blocked", goalId: goal.id, reason });
+        return { result: "failed", candidate, reason };
+    }
+    if (!result.ok) {
+        const reason = `执行未成功：${result.result ?? "未说明"}`;
+        deps.lineage?.noteTrust({ stage: "blocked", goalId: goal.id, reason });
+        return { result: "failed", candidate, reason };
+    }
+    const delta = result.progressDelta ?? 1;
+    deps.registry.recordProgress(goal.id, delta);
+    deps.lineage?.noteTrust({ stage: "progress", goalId: goal.id, progressDelta: delta });
+    const after = deps.registry.getGoal(goal.id);
+    const satisfied = after !== undefined && goalSatisfied(after);
+    if (satisfied && after !== undefined) {
+        deps.registry.setGoalStatus(after.id, "achieved");
+        deps.lineage?.noteTrust({ stage: "progress", goalId: after.id, progressDelta: delta, reason: "goal-achieved" });
+    }
+    else {
+        // **未达成不得静默结账**：显式记一条「仍未达成」。
+        deps.lineage?.noteTrust({ stage: "progress", goalId: goal.id, progressDelta: delta, reason: "goal-not-satisfied" });
+    }
+    return { result: "settled", candidate, attribution: { goalId: goal.id, progressDelta: delta } };
+}
+/**
+ * 登记一条托付并落 `registered` 事件（**登记与账本同一处** → 不会漏段）。
+ */
+export function openEntrustment(deps, input) {
+    const e = deps.registry.registerEntrustment(input);
+    deps.lineage?.noteTrust({ stage: "registered", entrustmentId: e.id, goalId: e.goalId });
+    return e;
+}
+/**
+ * 托付到达（第二段）：状态迁移 + `arrived` 事件（同一处 → 不会漏段）。
+ */
+export function arriveEntrustment(deps, entrustmentId) {
+    const e = deps.registry.markArrived(entrustmentId);
+    if (e === undefined)
+        return undefined;
+    deps.lineage?.noteTrust({ stage: "arrived", entrustmentId: e.id, goalId: e.goalId });
+    return e;
+}
+/** 托付条件的判定（**可判定**：到点 / 状态命中）。 */
+export function evaluateEntrustmentCondition(entrustment, now, state) {
+    const c = entrustment.condition;
+    if (c.type === "at")
+        return now >= c.dueAt;
+    if (state === undefined)
+        return false;
+    return state[c.key] === c.equals;
+}
+/**
+ * 关闭一条托付（**结账**；卡 D3：需要人决定的不得自动结账）。
+ *
+ * - `needsHuman` → 产出 human-gated 记录，**不结账**；
+ * - 否则 → 结账 + 落 `settled` 事件。
+ */
+export function closeEntrustment(deps, entrustmentId) {
+    const e = deps.registry.getEntrustment(entrustmentId);
+    if (e === undefined)
+        return { result: "human-gated", reason: "托付不存在" };
+    if (e.needsHuman === true) {
+        const reason = e.humanReason ?? "需要人决定";
+        deps.registry.markNeedsHuman(entrustmentId, reason);
+        deps.lineage?.noteTrust({ stage: "human-gated", entrustmentId, goalId: e.goalId, reason });
+        return { result: "human-gated", reason };
+    }
+    const settled = deps.registry.settle(entrustmentId);
+    if (settled === undefined) {
+        const reason = `托付当前状态不可结账（${e.status}）`;
+        deps.lineage?.noteTrust({ stage: "blocked", entrustmentId, goalId: e.goalId, reason });
+        return { result: "human-gated", reason };
+    }
+    deps.lineage?.noteTrust({ stage: "settled", entrustmentId, goalId: e.goalId });
+    return { result: "settled" };
+}
+/**
+ * 自主推进的**下一步发现**（卡 D7 的 L-D）。
+ *
+ * 来源：**未竟目标**（登记册里 `open` 的目标）与**未闭合待办**（未闭合的托付）。
+ * 不是凭空生成 —— 每个候选都能指回一条账本记录。
+ */
+export function discoverNextCandidates(deps, opts = {}) {
+    const out = [];
+    for (const goal of deps.registry.listOpenGoals()) {
+        out.push(...deriveCandidates(goal, opts));
+    }
+    for (const e of deps.registry.listUnclosedEntrustments()) {
+        out.push({
+            id: `${e.id}#close`,
+            entrustmentId: e.id,
+            goalId: e.goalId ?? "",
+            action: `处理未闭合托付：${e.target}`,
+            actionType: "write",
+            permission: resolvePermissionTier("write"),
+            scope: e.id,
+            reversible: true,
+            value: 1,
+            valueSource: "trust-loop: unclosed-entrustment",
+            urgency: 1,
+            urgencySource: "trust-loop: unclosed-entrustment",
+            interruptionCost: 1,
+            interruptionCostSource: "trust-loop: default",
+            score: 1,
+            band: "trigger",
+            reason: `账本里有一条未闭合托付：${e.target}（${e.status}）`,
+        });
+    }
+    return out;
+}