berry-agent 0.1.0-alpha.1

package/dist/goal/service.js

@@ -0,0 +1,501 @@
+/**
+ * goal 服务面（03 §10.5 + 04 §12 调度条 goal 挂钟节）。
+ *
+ * 编舞总览：
+ *  - 生命周期：activate（单 active 撞席守卫 + 挂钟注册）/ resume（重绑锚 +
+ *    复活挂钟）/ complete（完成否决律机器面：open 项在或 gate 未全绿即拒）/
+ *    abandon（终态同笔停摆）；
+ *  - 续跑触发：wake 双道（clock/manual）——重绑护栏（关闭后旧唤醒不落地）+
+ *    wakeGate 双帽（停滞判定帽 + 唤醒预算帽 §4）+ 停滞硬停（连续无进展即
+ *    停摆报告）+ 归因轮身份 durable 落账（goal_wakes 表——跨进程可审计）；
+ *  - 预算双轨（04 §5）：记账刹停腿（recordTurn 前台计数 + foldDelegation
+ *    委派结算折叠——两腿先到先刹）+ budgetExceeded 复验面（agent_pre_step
+ *    消费——防记账腿与执行腿竞速漏刹）；
+ *  - 挂钟行管理：GoalJobsFace 窄面单漏斗 + 第五槽迟到注入（先 goal 后
+ *    scheduler 装载序的补接线——effect 可逆双序对称）。
+ */
+import { randomUUID } from 'node:crypto';
+import { BaseError } from '../contracts/index.js';
+import { foldGoalTodos, openGoalItems, progressFingerprint } from './fold.js';
+import { evaluateGoalGates } from './gates.js';
+/** objective 硬帽（16KiB——与 scheduler prompt 帽同值） */
+const OBJECTIVE_MAX_BYTES = 16 * 1024;
+/** 停滞判定帽缺省（连续无进展唤醒轮数——超过即硬停报告） */
+export const DEFAULT_STALL_LIMIT = 5;
+/** 唤醒预算帽缺省（§4 maxConsecutiveWakes 同值——连续 clock 唤醒无进展即拒） */
+export const DEFAULT_WAKE_BUDGET_LIMIT = 3;
+/** 轮间沉淀摘要帽（04 §3.7 complete 单发 maxChars——注入面单条消息量级） */
+export const GOAL_DEPOSIT_MAX_CHARS = 2000;
+/** 沉淀单发提示词（objective + 计划态两段——单发即弃零会话态） */
+function depositPrompt(row, items) {
+    const completed = items.filter((item) => item.status === 'completed').length;
+    return [
+        '为长期目标的下一轮工作生成一段简短沉淀摘要（供下一轮对话开局注入）。',
+        `目标：${row.objective}`,
+        `当前计划态：open ${items.length - completed} 项 / completed ${completed} 项。`,
+        '要求：概括目标、当前进度与下一步建议，不含多余客套。',
+    ].join('\n');
+}
+/** goals 表行查列清单（单源——get/list/activeFor 共用） */
+const GOAL_COLUMNS = `id, session_id, objective, status, activated_seq, schedule, prompt_snapshot,
+                      needs_write, write_approved, budget_messages_cap, budget_messages_used, budget_folded_units,
+                      stall_streak, wake_streak, last_fingerprint, created_at, updated_at,
+                      ended_at, ending_note`;
+class GoalDao {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    get(id) {
+        const row = this.db.prepare(`SELECT ${GOAL_COLUMNS} FROM goals WHERE id = ?`).get(id);
+        return row ? goalFromDb(row) : undefined;
+    }
+    activeFor(sessionId) {
+        const row = this.db
+            .prepare(`SELECT ${GOAL_COLUMNS} FROM goals WHERE session_id = ? AND status = 'active' LIMIT 1`)
+            .get(sessionId);
+        return row ? goalFromDb(row) : undefined;
+    }
+    list() {
+        const rows = this.db.prepare(`SELECT ${GOAL_COLUMNS} FROM goals ORDER BY created_at DESC`).all();
+        return rows.map(goalFromDb);
+    }
+    insert(goal) {
+        this.db
+            .prepare(`INSERT INTO goals (id, session_id, objective, status, activated_seq, schedule, prompt_snapshot,
+                            needs_write, write_approved, budget_messages_cap, budget_messages_used, budget_folded_units,
+                            stall_streak, wake_streak, last_fingerprint, created_at, updated_at,
+                            ended_at, ending_note)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`)
+            .run(goal.id, goal.sessionId, goal.objective, goal.status, goal.activatedSeq, goal.schedule, goal.promptSnapshot, goal.needsWrite ? 1 : 0, goal.writeApproved ? 1 : 0, goal.budgetMessagesCap, goal.budgetMessagesUsed, goal.budgetFoldedUnits, goal.stallStreak, goal.wakeStreak, goal.lastFingerprint, goal.createdAt, goal.updatedAt, goal.endedAt, goal.endingNote);
+    }
+    /** 行更新（patch 形——updatedAt 调用方供） */
+    update(id, patch, updatedAt) {
+        const current = this.get(id);
+        if (!current)
+            return;
+        const next = { ...current, ...patch, updatedAt };
+        this.db
+            .prepare(`UPDATE goals SET session_id = ?, objective = ?, status = ?, activated_seq = ?, schedule = ?,
+                          prompt_snapshot = ?, needs_write = ?, write_approved = ?, budget_messages_cap = ?,
+                          budget_messages_used = ?, budget_folded_units = ?, stall_streak = ?,
+                          wake_streak = ?, last_fingerprint = ?, updated_at = ?, ended_at = ?,
+                          ending_note = ?
+         WHERE id = ?`)
+            .run(next.sessionId, next.objective, next.status, next.activatedSeq, next.schedule, next.promptSnapshot, next.needsWrite ? 1 : 0, next.writeApproved ? 1 : 0, next.budgetMessagesCap, next.budgetMessagesUsed, next.budgetFoldedUnits, next.stallStreak, next.wakeStreak, next.lastFingerprint, next.updatedAt, next.endedAt, next.endingNote, id);
+    }
+    remove(id) {
+        this.db.prepare(`DELETE FROM goals WHERE id = ?`).run(id);
+    }
+    insertWake(goalId, wokeAt, trigger, attribution, fingerprint, progressed) {
+        const result = this.db
+            .prepare(`INSERT INTO goal_wakes (goal_id, woke_at, trigger, attribution, fingerprint, progressed) VALUES (?, ?, ?, ?, ?, ?)`)
+            .run(goalId, wokeAt, trigger, attribution, fingerprint, progressed ? 1 : 0);
+        return {
+            id: Number(result.lastInsertRowid),
+            goalId,
+            wokeAt,
+            trigger,
+            attribution,
+            fingerprint,
+            progressed,
+        };
+    }
+    wakes(goalId) {
+        const rows = this.db
+            .prepare(`SELECT id, goal_id, woke_at, trigger, attribution, fingerprint, progressed
+                FROM goal_wakes WHERE goal_id = ? ORDER BY id`)
+            .all(goalId);
+        return rows.map((r) => ({
+            id: r.id,
+            goalId: r.goal_id,
+            wokeAt: r.woke_at,
+            trigger: r.trigger,
+            attribution: r.attribution,
+            fingerprint: r.fingerprint,
+            progressed: r.progressed === 1,
+        }));
+    }
+}
+/** DB 行 → 契约行 */
+function goalFromDb(row) {
+    return {
+        id: row.id,
+        sessionId: row.session_id,
+        objective: row.objective,
+        status: row.status,
+        activatedSeq: row.activated_seq,
+        schedule: row.schedule,
+        promptSnapshot: row.prompt_snapshot,
+        needsWrite: row.needs_write === 1,
+        writeApproved: row.write_approved === 1,
+        budgetMessagesCap: row.budget_messages_cap,
+        budgetMessagesUsed: row.budget_messages_used,
+        budgetFoldedUnits: row.budget_folded_units,
+        stallStreak: row.stall_streak,
+        wakeStreak: row.wake_streak,
+        lastFingerprint: row.last_fingerprint,
+        createdAt: row.created_at,
+        updatedAt: row.updated_at,
+        endedAt: row.ended_at,
+        endingNote: row.ending_note,
+    };
+}
+// ── 服务实装 ───────────────────────────────────────────────────────────────
+export function createGoalService(deps) {
+    const dao = new GoalDao(deps.db);
+    const now = deps.now;
+    const warn = deps.warn;
+    const newId = deps.newId ?? randomUUID;
+    const stallLimit = deps.stallLimit ?? DEFAULT_STALL_LIMIT;
+    const wakeBudgetLimit = deps.wakeBudgetLimit ?? DEFAULT_WAKE_BUDGET_LIMIT;
+    /** 挂钟窄面（迟到注入前 null——注册需求暂存） */
+    let jobsFace = null;
+    /** 迟到暂存面（先 goal 后 scheduler 装载序的补接线队列） */
+    const pendingClocks = new Set();
+    /** 轮间沉淀缓存（goalId → {指纹, 文本}——同指纹零 LLM 单发，批 #99） */
+    const depositCache = new Map();
+    /** 沉淀单发在飞位（同 goal 至多一次在飞——请求组装路径不排队堆积） */
+    const depositInFlight = new Set();
+    /** 预算停靠登记（u-3——04 §5 定形注③：parkForBudget 幂等判据 + 件侧唤醒收口现判面；进程内存位——durable 事实由挂钟行 disabled + 会话词承载，daemon 猝死后冷启动经挂钟停摆自然呈现） */
+    const parkedForBudget = new Set();
+    /** 单漏斗挂钟注册（activate 与 attach 冲洗共用；回执 {ok:false} 上抛响亮） */
+    async function registerClock(goal) {
+        if (jobsFace === null) {
+            pendingClocks.add(goal.id);
+            return;
+        }
+        const receipt = await jobsFace.register({
+            goalId: goal.id,
+            sessionId: goal.sessionId,
+            schedule: goal.schedule,
+            promptSnapshot: goal.promptSnapshot,
+        });
+        if (!receipt.ok) {
+            throw new BaseError('GOAL_TRANSITION_INVALID', `挂钟注册失败（goal ${goal.id}）：${receipt.message}`);
+        }
+    }
+    /**
+     * 双位合取单源闭包（f-1 定形注③——complete 评测位与 commandGateStatus
+     * 读面同源消费此一处，勿另写合取；s 批 U3 收口：评测位手写合取撤）
+     */
+    const commandGateStatusOf = (goalId) => {
+        const row = dao.get(goalId);
+        if (!row || !row.needsWrite)
+            return { allowed: false, reason: 'not-declared' };
+        if (!row.writeApproved)
+            return { allowed: false, reason: 'not-approved' };
+        return { allowed: true, reason: 'ok' };
+    };
+    const service = {
+        async activate(req) {
+            const bytes = Buffer.byteLength(req.objective, 'utf8');
+            if (req.objective.length === 0 || bytes > OBJECTIVE_MAX_BYTES) {
+                throw new BaseError('GOAL_GOAL_INVALID', `objective 须非空且 ≤16KiB（得 ${bytes} 字节）`);
+            }
+            if (dao.activeFor(req.sessionId)) {
+                throw new BaseError('GOAL_TRANSITION_INVALID', `会话 ${req.sessionId} 已有 active goal（单 active 守卫——先 complete/abandon 再建新）`);
+            }
+            const ts = now();
+            const goal = {
+                id: newId(),
+                sessionId: req.sessionId,
+                objective: req.objective,
+                status: 'active',
+                activatedSeq: deps.session.length(req.sessionId),
+                schedule: req.schedule,
+                promptSnapshot: req.promptSnapshot ?? `继续推进目标：${req.objective}`,
+                needsWrite: req.needsWrite === true,
+                writeApproved: false, // 批准位恒由 /goal approve 后置（f-1 定形注②——申报非授权）
+                budgetMessagesCap: req.budgetMessagesCap ?? null,
+                budgetMessagesUsed: 0,
+                budgetFoldedUnits: 0,
+                stallStreak: 0,
+                wakeStreak: 0,
+                lastFingerprint: null,
+                createdAt: ts,
+                updatedAt: ts,
+                endedAt: null,
+                endingNote: null,
+            };
+            dao.insert(goal);
+            try {
+                await registerClock(goal);
+            }
+            catch (err) {
+                dao.remove(goal.id); // 注册失败回卷建行（不半态——goal 行与挂钟行同笔生死）
+                throw err;
+            }
+            return dao.get(goal.id);
+        },
+        async resume(goalId, opts) {
+            const row = dao.get(goalId);
+            if (!row)
+                throw new BaseError('GOAL_NOT_FOUND', `goal「${goalId}」不存在（resume 幽灵 id 零行守卫）`);
+            if (row.status !== 'active') {
+                throw new BaseError('GOAL_TRANSITION_INVALID', `goal「${goalId}」已终态（${row.status}）——终态不复活，重开走新 goal`);
+            }
+            const sessionId = opts?.sessionId ?? row.sessionId;
+            // 易主守卫：目标会话已有别的 active goal 时拒绝重绑（单 active 不因易主破例）
+            const incumbent = dao.activeFor(sessionId);
+            if (incumbent !== undefined && incumbent.id !== goalId) {
+                throw new BaseError('GOAL_TRANSITION_INVALID', `会话 ${sessionId} 已有 active goal「${incumbent.id}」——重绑撞席拒`);
+            }
+            dao.update(goalId, {
+                sessionId,
+                activatedSeq: deps.session.length(sessionId),
+                stallStreak: 0,
+                wakeStreak: 0,
+                lastFingerprint: null,
+            }, now());
+            await jobsFace?.enable(goalId); // 复活挂钟（停滞硬停后 resume 同律）
+            return dao.get(goalId);
+        },
+        async complete(goalId, evidence) {
+            const row = dao.get(goalId);
+            if (!row)
+                throw new BaseError('GOAL_NOT_FOUND', `goal「${goalId}」不存在（complete 幽灵 id 零行守卫）`);
+            if (row.status !== 'active') {
+                throw new BaseError('GOAL_TRANSITION_INVALID', `goal「${goalId}」已终态（${row.status}）——不可再迁转`);
+            }
+            if (evidence.trim().length === 0) {
+                throw new BaseError('GOAL_TRANSITION_INVALID', 'goal_update 终态 completed 必附 evidence（非空——申报与验证分离，自报文本非唯一通道）');
+            }
+            // 完成否决律：goal-scoped 计划态 open 项机器否决（响亮列 open 项）
+            const items = foldGoalTodos(deps.session.events(row.sessionId), row.activatedSeq);
+            const open = openGoalItems(items);
+            if (open.length > 0) {
+                const listing = open.map((item) => `[${item.status}] ${item.content}`).join('；');
+                throw new BaseError('GOAL_TRANSITION_INVALID', `完成否决——尚有 ${open.length} 个 open 项（open = 一切非 completed 项，deferred 含内无论窗到否）：${listing}`);
+            }
+            // 携 gate 项须全绿（fail-closed 评测——seam 缺席即该门 fail）
+            const outcomes = await evaluateGoalGates(items, {
+                ...deps.gates,
+                // 双位合取终判（f-1 定形注③——评测位防御纵深：越路径直写事件流的
+                // command gate 条目在此兜底否决；单源闭包消费非手写合取〔s 批 U3〕）
+                commandGateAllowed: commandGateStatusOf(goalId).allowed,
+            });
+            const failed = outcomes.filter((o) => !o.ok);
+            if (failed.length > 0) {
+                const listing = failed.map((o) => `${o.kind} 门：${o.detail}`).join('；');
+                throw new BaseError('GOAL_TRANSITION_INVALID', `完成否决——判据门未全绿（${listing}）`);
+            }
+            dao.update(goalId, { status: 'completed', endedAt: now(), endingNote: evidence }, now());
+            parkedForBudget.delete(goalId); // 终态清停靠登记（广播面不再辖终态 goal）
+            await jobsFace?.disable(goalId); // 终态同笔停摆（行留史）
+            return dao.get(goalId);
+        },
+        async abandon(goalId, reason) {
+            const row = dao.get(goalId);
+            if (!row)
+                throw new BaseError('GOAL_NOT_FOUND', `goal「${goalId}」不存在（abandon 幽灵 id 零行守卫）`);
+            if (row.status !== 'active') {
+                throw new BaseError('GOAL_TRANSITION_INVALID', `goal「${goalId}」已终态（${row.status}）——不可再迁转`);
+            }
+            dao.update(goalId, { status: 'abandoned', endedAt: now(), endingNote: reason ?? 'abandoned' }, now());
+            parkedForBudget.delete(goalId); // 终态清停靠登记（广播面不再辖终态 goal）
+            await jobsFace?.disable(goalId);
+            return dao.get(goalId);
+        },
+        async wake(goalId, opts) {
+            const row = dao.get(goalId);
+            if (!row)
+                throw new BaseError('GOAL_NOT_FOUND', `goal「${goalId}」不存在（wake 幽灵 id 零行守卫）`);
+            // 重绑护栏：goal 关闭（终态）后旧唤醒不落地
+            if (row.status !== 'active') {
+                return {
+                    landed: false,
+                    reason: 'inactive',
+                    message: `goal「${goalId}」已终态（${row.status}）——唤醒不落地（重绑护栏）`,
+                    goal: row,
+                };
+            }
+            const fingerprint = progressFingerprint(foldGoalTodos(deps.session.events(row.sessionId), row.activatedSeq));
+            const progressed = row.lastFingerprint === null ? true : fingerprint !== row.lastFingerprint;
+            // manual 道：手动起闹——停滞/预算双复位 + 挂钟复活（用户显式意图，双帽不辖）。
+            // u-3 停靠让位：人工复位即人工接管——预算停靠登记同笔摘除（广播唤醒面
+            // 让位，防广播翻真后对已复活 goal 再 submit 双跑）
+            if (opts.trigger === 'manual') {
+                parkedForBudget.delete(goalId);
+                dao.update(goalId, { stallStreak: 0, wakeStreak: 0, lastFingerprint: fingerprint }, now());
+                await jobsFace?.enable(goalId);
+                dao.insertWake(goalId, now(), 'manual', opts.attribution, fingerprint, progressed);
+                const fresh = dao.get(goalId);
+                return { landed: true, reason: 'ok', message: `手动唤醒已落地（停滞计数复位）`, goal: fresh };
+            }
+            // clock 道：wakeGate 双帽——进展即双复位直落；无进展走双帽判定
+            if (progressed) {
+                dao.update(goalId, { stallStreak: 0, wakeStreak: 0, lastFingerprint: fingerprint }, now());
+                dao.insertWake(goalId, now(), 'clock', opts.attribution, fingerprint, true);
+                return { landed: true, reason: 'ok', message: '唤醒落地（计划态有进展）', goal: dao.get(goalId) };
+            }
+            const stallStreak = row.stallStreak + 1;
+            if (stallStreak >= stallLimit) {
+                // 停滞硬停：连续 N 轮无进展即停摆报告（不无限空转烧预算）——挂钟停摆
+                // 留用户复位道（/goal wake 手动起闹 / resume 重绑），goal 行保持 active
+                dao.update(goalId, { stallStreak, lastFingerprint: fingerprint }, now());
+                await jobsFace?.disable(goalId);
+                warn(`[goal] 停滞硬停：goal「${goalId}」连续 ${stallStreak} 轮唤醒无进展——挂钟停摆（/goal wake 可复位重跑）`);
+                return {
+                    landed: false,
+                    reason: 'stalled',
+                    message: `停滞硬停：连续 ${stallStreak} 轮唤醒无进展（帽 ${stallLimit}）——挂钟已停摆，/goal wake 手动复位`,
+                    goal: dao.get(goalId),
+                };
+            }
+            const wakeStreak = row.wakeStreak + 1;
+            if (wakeStreak >= wakeBudgetLimit) {
+                // 唤醒预算帽（§4 maxConsecutiveWakes）：连续 clock 唤醒无进展即拒再唤醒
+                // （落 warn 不硬停——进展/用户轮/manual 任一即复位）
+                dao.update(goalId, { stallStreak, wakeStreak, lastFingerprint: fingerprint }, now());
+                warn(`[goal] 唤醒预算拒收：goal「${goalId}」连续 ${wakeStreak} 次无进展 clock 唤醒（帽 ${wakeBudgetLimit}）`);
+                return {
+                    landed: false,
+                    reason: 'wake_budget',
+                    message: `唤醒预算拒收：连续 ${wakeStreak} 次无进展 clock 唤醒（帽 ${wakeBudgetLimit}）——本轮不起`,
+                    goal: dao.get(goalId),
+                };
+            }
+            dao.update(goalId, { stallStreak, wakeStreak, lastFingerprint: fingerprint }, now());
+            dao.insertWake(goalId, now(), 'clock', opts.attribution, fingerprint, false);
+            return { landed: true, reason: 'ok', message: '唤醒落地（无进展——停滞/唤醒计数 +1）', goal: dao.get(goalId) };
+        },
+        get: (goalId) => dao.get(goalId),
+        activeFor: (sessionId) => dao.activeFor(sessionId),
+        list: () => dao.list(),
+        wakes: (goalId) => dao.wakes(goalId),
+        async approve(goalId) {
+            const row = dao.get(goalId);
+            if (!row)
+                throw new BaseError('GOAL_NOT_FOUND', `goal「${goalId}」不存在（approve 幽灵 id 零行守卫）`);
+            // 批准无对象两档：未申报 needsWrite（approve 前置语义缺位）/ 终态行
+            // （生命周期已收口——f-1 定形注②守卫链）
+            if (!row.needsWrite) {
+                throw new BaseError('GOAL_TRANSITION_INVALID', `goal「${goalId}」未申报 needsWrite——无批准对象（activate 时申报后方可批准）`);
+            }
+            if (row.status !== 'active') {
+                throw new BaseError('GOAL_TRANSITION_INVALID', `goal「${goalId}」已终态（${row.status}）——批准无对象`);
+            }
+            if (row.writeApproved)
+                return row; // 重复 approve 幂等回执（批准位已置）
+            dao.update(goalId, { writeApproved: true }, now());
+            return dao.get(goalId);
+        },
+        commandGateStatus(goalId) {
+            // 执行期活查（f-1 定形注③——恒按当前行求值；幽灵行防御位归 not-declared，
+            // 正常路径 scope 活则行恒在）——单源闭包消费（s 批 U3：与 complete 评测位同源）
+            return commandGateStatusOf(goalId);
+        },
+        recordTurn(goalId, opts) {
+            const row = dao.get(goalId);
+            if (!row)
+                throw new BaseError('GOAL_NOT_FOUND', `goal「${goalId}」不存在（recordTurn 幽灵 id 零行守卫——装配接线错位）`);
+            // 记账单位 = 本窗 durable assistant/message 条数（04 §176——批 #99 驱动
+            // 窗扫供给；缺省 1 兼容旧单笔调用形）
+            const used = row.budgetMessagesUsed + Math.max(1, Math.floor(opts?.messages ?? 1));
+            dao.update(goalId, { budgetMessagesUsed: used, ...(opts?.userInitiated ? { wakeStreak: 0 } : {}) }, now());
+            const folded = row.budgetFoldedUnits;
+            return {
+                braked: row.budgetMessagesCap !== null && used + folded >= row.budgetMessagesCap,
+                used,
+                cap: row.budgetMessagesCap,
+            };
+        },
+        foldDelegation(goalId, units) {
+            const row = dao.get(goalId);
+            if (!row)
+                throw new BaseError('GOAL_NOT_FOUND', `goal「${goalId}」不存在（foldDelegation 幽灵 id 零行守卫）`);
+            dao.update(goalId, { budgetFoldedUnits: row.budgetFoldedUnits + Math.max(0, Math.floor(units)) }, now());
+        },
+        budgetExceeded(goalId) {
+            const row = dao.get(goalId);
+            if (!row)
+                throw new BaseError('GOAL_NOT_FOUND', `goal「${goalId}」不存在（budgetExceeded 幽灵 id 零行守卫）`);
+            return row.budgetMessagesCap !== null && row.budgetMessagesUsed + row.budgetFoldedUnits >= row.budgetMessagesCap;
+        },
+        async parkForBudget(goalId) {
+            const row = dao.get(goalId);
+            if (!row)
+                throw new BaseError('GOAL_NOT_FOUND', `goal「${goalId}」不存在（parkForBudget 幽灵 id 零行守卫）`);
+            // 终态 goal 无停靠语义（重绑护栏同律——终态行挂钟本已停摆）
+            if (row.status !== 'active')
+                return false;
+            // 幂等判据：已停靠 no-op（复验/记账/池检三触发位竞速时首笔落全、余笔蒸发）
+            if (parkedForBudget.has(goalId))
+                return true;
+            parkedForBudget.add(goalId);
+            // 挂钟行 disable（起停载体——行留史、广播恢复时 enable 复活；无行 = 静默
+            // no-op 既有律）。goal 行 status 三值 CHECK 不动（04 §5 定形注③）
+            await jobsFace?.disable(goalId);
+            // 会话落停靠词（daemon 猝死后冷启动可恢复呈现——05 §1.1 词行；宿主侧
+            // 真身幂等开驱动后 append，会话缺席由窄面真身诚实处置）
+            deps.session.appendPaused(row.sessionId);
+            warn(`[goal] 预算停靠：goal「${goalId}」（会话 ${row.sessionId}）挂钟停摆 + 会话落 session/paused——待 budget_extended 广播唤醒（人工复位道：/goal wake）`);
+            return true;
+        },
+        isParkedForBudget: (goalId) => parkedForBudget.has(goalId),
+        unparkForBudget(goalId) {
+            parkedForBudget.delete(goalId);
+        },
+        async reviveClock(goalId) {
+            await jobsFace?.enable(goalId);
+        },
+        depositFor(sessionId) {
+            const row = dao.activeFor(sessionId);
+            if (row === undefined)
+                return null; // 无 active goal = 零注入（驱动同形降级）
+            const items = foldGoalTodos(deps.session.events(sessionId), row.activatedSeq);
+            const fingerprint = progressFingerprint(items);
+            const cached = depositCache.get(row.id);
+            if (cached !== undefined && cached.fingerprint === fingerprint)
+                return cached.text;
+            // 指纹已变（或缓存冷）：确定性回退立即承载 + 后台单发刷新（fire-and-
+            // forget——请求组装路径零等待；同指纹失败也缓存回退，杜绝每请求重烧）
+            const completed = items.filter((item) => item.status === 'completed').length;
+            const fallback = `目标：${row.objective}\n计划态：open ${items.length - completed} 项 / completed ${completed} 项`;
+            if (deps.summarizer !== undefined && !depositInFlight.has(row.id)) {
+                depositInFlight.add(row.id);
+                void deps.summarizer
+                    .complete({ prompt: depositPrompt(row, items), maxChars: GOAL_DEPOSIT_MAX_CHARS })
+                    .then((out) => {
+                    depositCache.set(row.id, { fingerprint, text: out.text.trim() === '' ? fallback : out.text });
+                })
+                    .catch((err) => {
+                    warn(`[goal] 沉淀摘要单发失败（确定性回退承载同指纹缓存）：${err instanceof Error ? err.message : String(err)}`);
+                    depositCache.set(row.id, { fingerprint, text: fallback });
+                })
+                    .finally(() => depositInFlight.delete(row.id));
+            }
+            return cached !== undefined ? cached.text : fallback;
+        },
+        goalScopeFor(sessionId) {
+            const row = dao.activeFor(sessionId);
+            return row === undefined ? undefined : { goalId: row.id, activatedSeq: row.activatedSeq };
+        },
+        async attachGoalJobsFace(face) {
+            jobsFace = face;
+            // 迟到冲洗：暂存的挂钟需求逐笔补登记（失败 warn 亮拒不炸装配——goal 行
+            // 留在场、挂钟缺席的事实交 /goal list 呈现与用户处置）
+            const queued = [...pendingClocks];
+            pendingClocks.clear();
+            for (const goalId of queued) {
+                const row = dao.get(goalId);
+                if (!row || row.status !== 'active')
+                    continue; // 终态/已删行的迟到需求蒸发
+                const receipt = await face.register({
+                    goalId: row.id,
+                    sessionId: row.sessionId,
+                    schedule: row.schedule,
+                    promptSnapshot: row.promptSnapshot,
+                });
+                if (!receipt.ok) {
+                    warn(`[goal] 迟到挂钟注册失败：goal「${goalId}」${receipt.message}（挂钟缺席——schedule 坏串请修正后 resume）`);
+                }
+            }
+        },
+        detachGoalJobsFace() {
+            jobsFace = null; // effect 可逆回卷（后续注册再暂存——双序对称）
+        },
+    };
+    return service;
+}