libero3 0.3.0

package/dist/mcp/server-core.js

@@ -0,0 +1,1334 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { createRepos } from "./src/repo/factory.js";
+import { createCategoryTools } from "./src/categories/index.js";
+import { createTimeBlockTools } from "./src/timeblock/index.js";
+import { createStatsTools } from "./src/stats/index.js";
+import { createMatrixTools } from "./src/matrix/index.js";
+import { createTimelineTools } from "./src/timeline/index.js";
+import { createTimerTools } from "./src/timer/index.js";
+import { createProfileTools } from "./src/profile/index.js";
+import { createProfileConfirmTools } from "./src/profile/confirm-default.js";
+import { createReminderTools } from "./src/reminder/index.js";
+import { createSchedulerTools } from "./src/scheduler/index.js";
+import { createAdaptersWithDb, selectAdapter } from "./src/host-adapters/index.js";
+import { createTaskTools } from "./src/task/index.js";
+import { createCoachModTools } from "./src/coachmod/index.js";
+import { createApTools } from "./src/ap/index.js";
+import { timerMinMinutes } from "./src/ap/rewards.js";
+import { FsYamlKnowledgeRepo } from "../knowledge/src/repo/fs-yaml.js";
+import { nowLocal, formatTime, parseTime } from "./src/clock/index.js";
+import { buildServerInstructions } from "./cold-start.js";
+import { resolveUserId } from "./src/identity/resolve.js";
+import { profileIdForWrite } from "./src/identity/equivalent-ids.js";
+import { resolveDefaultUserId, logResolvedDefaultUserId, } from "./src/user-id-resolver.js";
+/** Wrap any tool result as MCP text content (JSON). Void results become {ok:true}. */
+function asContent(result) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(result !== undefined ? result : { ok: true }),
+            },
+        ],
+    };
+}
+/** Inject default user_id; map alias → existing user_profile.id for FK writes (地基②). */
+export function makeUserIdInjector(defaultUserId, db) {
+    return function inject(input) {
+        const raw = input.user_id || defaultUserId;
+        if (!raw) {
+            return {
+                error: "user_id is required (no default configured: set LIBERO_DEFAULT_USER_ID or have at least one non-system user_profile)",
+            };
+        }
+        const user_id = profileIdForWrite(db, raw) ?? raw;
+        return { ...input, user_id };
+    };
+}
+export function errorContent(msg, code) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify(code ? { error: msg, code } : { error: msg }),
+            },
+        ],
+        isError: true,
+    };
+}
+/**
+ * Build the full tool registry (48 tools). Each entry is a data-fied version of
+ * the pre-refactor inline registration calls — handlers are byte-for-byte copies
+ * preserving declaration order for diagnostic readability.
+ */
+function buildToolRegistry(ctx) {
+    // INT-ap-rewards：实绩事件 → 换算引擎入账。声明折叠（AGENTS §4.5）：
+    // 奖励失败不阻断业务动作本身，stderr 告警；事件未消费，重放同 event_id 可补。
+    // 返回 {nth, amount, bonus?}（null=重放）并入工具响应，让脑层能播报 AP 变动。
+    const rewardHook = async (userId, action_type, eventId) => {
+        if (!userId)
+            return null;
+        try {
+            return await ctx.repos.apRepo.recordRewardEvent({ user_id: userId, action_type, event_id: eventId });
+        }
+        catch (e) {
+            console.error(`[rewards] ${action_type} hook failed for ${userId}:`, e);
+            return null;
+        }
+    };
+    const { categories, tb, stats, matrix, timeline, timer, profile, profileConfirm, reminder, scheduler, task, coachmod, ap, injector, } = ctx;
+    // identityRepo is referenced directly inside handlers below (closure scope),
+    // matching the pre-refactor behavior.
+    const identityRepo = ctx.repos.identityRepo;
+    const tools = [];
+    // ============================================================
+    // categories (2 tools)
+    // ============================================================
+    tools.push({
+        name: "categories.getAll",
+        description: "获取全部时间分类（15 类）",
+        inputSchema: {},
+        handler: async () => asContent(await categories.getAllCategories()),
+    });
+    tools.push({
+        name: "categories.getById",
+        description: "按 id 获取单个分类",
+        inputSchema: { id: z.string().min(1) },
+        handler: async ({ id }) => asContent(await categories.getCategoryById(id)),
+    });
+    // ============================================================
+    // timer (9 tools — positional userId args, R4 pattern)
+    // ============================================================
+    tools.push({
+        name: "timer.start",
+        description: "开始一个计时会话",
+        inputSchema: {
+            user_id: z.string().optional(),
+            target_user_id: z.string().min(1).optional(),
+            event: z.string().min(1),
+            categoryId: z.string().optional(),
+            task_id: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await timer.start(r.user_id, r.event, r.categoryId, r.task_id, r.target_user_id));
+        },
+    });
+    tools.push({
+        name: "timer.pause",
+        description: "暂停当前计时",
+        inputSchema: { user_id: z.string().optional() },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await timer.pause(r.user_id));
+        },
+    });
+    tools.push({
+        name: "timer.resume",
+        description: "恢复已暂停的计时",
+        inputSchema: { user_id: z.string().optional() },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await timer.resume(r.user_id));
+        },
+    });
+    tools.push({
+        name: "timer.stop",
+        description: "停止计时并返回记录（传 rating 时自动落盘 timeblock）",
+        inputSchema: {
+            user_id: z.string().optional(),
+            rating: z.number().min(1).max(5).optional(),
+            rating_reason: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            const rec = await timer.stop(r.user_id, {
+                rating: r.rating,
+                rating_reason: r.rating_reason,
+            });
+            // INT-ap-rewards：有效时长 ≥ 门槛才算计时实绩（spec §2）
+            if (rec.durationMin >= timerMinMinutes()) {
+                const ap = await rewardHook(r.user_id, "timer", `timer:${r.user_id}:${rec.startedAt}`);
+                if (ap)
+                    return asContent({ ...rec, ap });
+            }
+            return asContent(rec);
+        },
+    });
+    tools.push({
+        name: "timer.status",
+        description: "查询某用户当前计时状态",
+        inputSchema: { user_id: z.string().optional() },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await timer.status(r.user_id));
+        },
+    });
+    tools.push({
+        name: "timer.elapsed",
+        description: "查询当前计时已过毫秒数",
+        inputSchema: { user_id: z.string().optional() },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await timer.elapsed(r.user_id));
+        },
+    });
+    tools.push({
+        name: "timer.statusAll",
+        description: "查询所有用户的当前计时状态（调试/兜底用）",
+        inputSchema: {},
+        handler: async () => asContent(await timer.statusAll()),
+    });
+    // ── S26: pomodoro v1 tools ──
+    tools.push({
+        name: "timer.startFocus",
+        description: "开始一个专注计时（番茄钟），带目标时长",
+        inputSchema: {
+            user_id: z.string().optional(),
+            event: z.string().min(1),
+            focusMin: z.number().positive().optional(),
+            categoryId: z.string().optional(),
+            task_id: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await timer.startFocus(r.user_id, r.event, r.focusMin, r.categoryId, r.task_id));
+        },
+    });
+    tools.push({
+        name: "timer.remaining",
+        description: "查询专注计时剩余时间（负数=超时）",
+        inputSchema: {
+            user_id: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await timer.remaining(r.user_id));
+        },
+    });
+    // ============================================================
+    // timeblock (6 tools — single-object args)
+    // ============================================================
+    tools.push({
+        name: "timeblock.create",
+        description: "创建一条时间记录",
+        inputSchema: {
+            user_id: z.string().optional(),
+            target_user_id: z.string().min(1).optional(),
+            title: z.string().min(1),
+            category_id: z.string().optional(),
+            start_time: z.string(),
+            end_time: z.string(),
+            duration_minutes: z.number().optional(),
+            rating: z.number().min(1).max(5).optional(),
+            rating_reason: z.string().optional(),
+            notes: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            const created = await tb.create(r);
+            // INT-ap-rewards：repo 层 create 默认 status='completed'（补录语义），
+            // 创建即完成也要计实绩（2026-09-02 事故：补录全漏挂钩）。
+            if ("user_id" in created && created.status === "completed") {
+                const ap = await rewardHook(created.user_id, "schedule", `tb:${created.id}`);
+                if (ap)
+                    return asContent({ ...created, ap });
+            }
+            return asContent(created);
+        },
+    });
+    tools.push({
+        name: "timeblock.getById",
+        description: "按 id 获取单条时间记录。" +
+            "S41 多用户：默认按当前 user_id 过滤，跨用户查不到返回 null。",
+        inputSchema: {
+            id: z.string().min(1),
+            user_id: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await tb.getById(rawInput.id, r.user_id));
+        },
+    });
+    tools.push({
+        name: "timeblock.update",
+        description: "更新一条时间记录（标题/时间/评分/status 等）。" +
+            "MV-COACH-3 Slice 4 用户主权状态机：" +
+            "① 开工 cron 触发到点 → status='unverified'（等用户核实，**不计入实绩**）；" +
+            "② 用户确认执行（主动开始计时 / 回报「执行了」/ 追问后答执行了）→ status='completed'（**唯一计入实绩**）；" +
+            "③ 用户答「没执行」→ 不改 status，直接 timeblock.remove 软删（留 deleted_at 可复盘，不进实绩统计）；" +
+            "④ 用户一直不答 → 保持 unverified，永远等（不自动判死）。" +
+            "⚠️ LLM 不能擅自把 planned/unverified 升级到 completed——只有用户确认才能升。",
+        inputSchema: {
+            id: z.string().min(1),
+            target_user_id: z.string().min(1).optional(),
+            title: z.string().optional(),
+            category_id: z.string().optional(),
+            start_time: z.string().optional(),
+            end_time: z.string().optional(),
+            duration_minutes: z.number().optional(),
+            rating: z.number().min(1).max(5).optional(),
+            rating_reason: z.string().optional(),
+            notes: z.string().optional(),
+            status: z.enum(["planned", "unverified", "completed"]).optional(),
+        },
+        handler: async ({ id, ...rest }) => {
+            const updated = await tb.update(id, rest);
+            // INT-ap-rewards：用户确认执行（status=completed）= 唯一计入实绩的日程信号。
+            // NeedsConfirm 返回 = 块未落 completed，不挂钩；timer.stop 内部直改 repo
+            // 不走本工具 → 计时/日程曲线天然去重（spec §2）。
+            if (rest.status === "completed" && "user_id" in updated) {
+                const ap = await rewardHook(updated.user_id, "schedule", `tb:${id}`);
+                if (ap)
+                    return asContent({ ...updated, ap });
+            }
+            return asContent(updated);
+        },
+    });
+    tools.push({
+        name: "timeblock.remove",
+        description: "软删除一条时间记录",
+        inputSchema: {
+            id: z.string().min(1),
+            target_user_id: z.string().min(1).optional(),
+        },
+        handler: async ({ id, target_user_id }) => asContent(await tb.remove(id, { target_user_id })),
+    });
+    tools.push({
+        name: "timeblock.restore",
+        description: "恢复一条已软删除的时间记录",
+        inputSchema: { id: z.string().min(1) },
+        handler: async ({ id }) => asContent(await tb.restore(id)),
+    });
+    tools.push({
+        name: "timeblock.list",
+        description: "按条件查询时间记录列表",
+        inputSchema: {
+            user_id: z.string().optional(),
+            target_user_id: z.string().min(1).optional(),
+            date: z.string().optional(),
+            from: z.string().optional(),
+            to: z.string().optional(),
+            category_id: z.string().optional(),
+            include_deleted: z.boolean().optional(),
+            limit: z.number().optional(),
+            offset: z.number().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await tb.list(r));
+        },
+    });
+    tools.push({
+        name: "timeblock.sweepStale",
+        description: "S43 过期扫描：列出某用户当天过期未确认的 timeblock，分两组返回。" +
+            "to_unverified：end_time 已过 30min 仍 planned（该升级 unverified）。" +
+            "to_ask：end_time 已过 60min 仍 unverified/planned，**且未被问过**（S48：每条只问一次，asked_at IS NULL）。" +
+            "⚠️ 纯查询，不改 db——caller（cron-session LLM）需对 to_unverified 显式调 timeblock.update(status=unverified)，对 to_ask 调 cronjob create 发追问，**发完后必须调 timeblock.markAsked(ids) 幂等标记**（否则下次扫描还会再问）。" +
+            "⚠️ 仅 cron-session 调用；user_id 必填。",
+        inputSchema: {
+            user_id: z.string().min(1),
+            now: z.string().optional(),
+            overdue_min_to_unverified: z.number().optional(),
+            overdue_min_to_ask: z.number().optional(),
+        },
+        handler: async (rawInput) => {
+            try {
+                const result = await tb.sweepStale({
+                    user_id: rawInput.user_id,
+                    now: rawInput.now,
+                    overdue_min_to_unverified: rawInput.overdue_min_to_unverified,
+                    overdue_min_to_ask: rawInput.overdue_min_to_ask,
+                });
+                return asContent(result);
+            }
+            catch (e) {
+                return errorContent(e.message);
+            }
+        },
+    });
+    tools.push({
+        name: "timeblock.markAsked",
+        description: "S48 幂等标记：把给定 timeblock 的 asked_at 设为当前时间。" +
+            "libero-cron-scan 发完追问后必须调用，否则同一条 unverified 会被下次扫描重复追问。" +
+            "asked_at 永久保留作审计；用户回报（completed / 软删）后这条不再被扫，无需复位。" +
+            "返回 { marked: N }（受影响行数）。⚠️ 仅 cron-session 调用。",
+        inputSchema: {
+            ids: z.array(z.string().min(1)).min(1),
+        },
+        handler: async (rawInput) => {
+            try {
+                const result = await tb.markAsked(rawInput.ids);
+                return asContent(result);
+            }
+            catch (e) {
+                return errorContent(e.message);
+            }
+        },
+    });
+    // ============================================================
+    // coachmod (2 tools — COACH-MOD §4，情境化复盘模块装载)
+    // ============================================================
+    tools.push({
+        name: "coachmod.suggest",
+        description: "COACH-MOD §4.1 情境化复盘模块装载——粗筛候选。" +
+            "按 context_hint + 用户 profile.focus_areas 确定性匹配 scenario-packs，始终附默认基础分析模型。" +
+            "脑（coach skill）拿到候选后**语义精选**并提议给用户（必经同意门，不静默装）。" +
+            "无候选 → candidates:[] + note（不静默空当正常）。user_id / context_hint 都可选。",
+        inputSchema: {
+            user_id: z.string().optional(),
+            context_hint: z.string().optional(),
+        },
+        handler: async (rawInput) => {
+            try {
+                const result = await coachmod.suggest({
+                    user_id: rawInput.user_id,
+                    context_hint: rawInput.context_hint,
+                });
+                return asContent(result);
+            }
+            catch (e) {
+                return errorContent(e.message);
+            }
+        },
+    });
+    tools.push({
+        name: "coachmod.load",
+        description: "COACH-MOD §4.2 情境化复盘模块装载——渐进披露取内容。" +
+            "只返回请求的 ids（脑精选后传）；scenario-pack id 展开其 recommends（画像+模型+subskill_prompt）。" +
+            "不存在的 id 报错（不静默返回空 loaded）。ids 必填。",
+        inputSchema: {
+            ids: z.array(z.string().min(1)).min(1),
+        },
+        handler: async (rawInput) => {
+            try {
+                const result = await coachmod.load({ ids: rawInput.ids });
+                return asContent(result);
+            }
+            catch (e) {
+                return errorContent(e.message);
+            }
+        },
+    });
+    // ============================================================
+    // stats (2 tools — single-object filters)
+    // ============================================================
+    tools.push({
+        name: "stats.summarize",
+        description: "按分类汇总时间统计（占比/记录数）",
+        inputSchema: {
+            user_id: z.string().optional(),
+            target_user_id: z.string().min(1).optional(),
+            from: z.string().optional(),
+            to: z.string().optional(),
+            category_id: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await stats.summarize(r));
+        },
+    });
+    tools.push({
+        name: "stats.dailyBreakdown",
+        description: "按天×分类拆分时间明细",
+        inputSchema: {
+            user_id: z.string().optional(),
+            target_user_id: z.string().min(1).optional(),
+            from: z.string().optional(),
+            to: z.string().optional(),
+            category_id: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await stats.dailyBreakdown(r));
+        },
+    });
+    // ============================================================
+    // matrix (1 tool — single-object filters, reuses StatsRepo)
+    // ============================================================
+    tools.push({
+        name: "matrix.renderMatrix",
+        description: "时间×评分四象限矩阵（能耗黑洞/保持区/亮点区/可放弃）。" +
+            "⚠️ 用户说「时间矩阵 / 时间表 / 看日程 / 今天时间表」时**不要**调本工具——那些是指 emoji 时间块视图，请改调 schedule.timeline。" +
+            "本工具仅用于：阶段复盘（这周/最近 N 天）+ 已评分记录的象限分析。",
+        inputSchema: {
+            user_id: z.string().optional(),
+            from: z.string().optional(),
+            to: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await matrix.renderMatrix(r));
+        },
+    });
+    // ============================================================
+    // schedule.timeline (emoji matrix + detail table)
+    // ============================================================
+    tools.push({
+        name: "schedule.timeline",
+        description: "看日程/复盘的首选视图：emoji 矩阵+细项表格，含计划/计时中/未回应/实绩全状态。" +
+            "用户说「看今天/看日程/在干啥/复盘/接下来 N 小时/时间矩阵/时间表/今天时间表」时调本工具，并直接 echo rendered_text（不重写、不改格式）。" +
+            "不要调 scheduler.listSchedules（那是内部排程查询，不是用户视图）。",
+        inputSchema: {
+            user_id: z.string().optional(),
+            target_user_id: z.string().min(1).optional(),
+            from: z.string().optional(),
+            to: z.string().optional(),
+            format: z.enum(["emoji", "ascii"]).optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await timeline.renderTimeline(r));
+        },
+    });
+    // ============================================================
+    // clock (3 tools — pure functions, no repo)
+    // ============================================================
+    tools.push({
+        name: "clock.now",
+        description: "返回当前 ISO 时间字符串（可选时区偏移）",
+        inputSchema: {
+            offsetMinutes: z.number().optional(),
+        },
+        handler: async ({ offsetMinutes }) => asContent(offsetMinutes !== undefined ? nowLocal(offsetMinutes) : nowLocal()),
+    });
+    tools.push({
+        name: "clock.formatTime",
+        description: "按指定格式格式化 ISO 时间",
+        inputSchema: {
+            iso: z.string().min(1),
+            format: z.string().min(1),
+        },
+        handler: async ({ iso, format }) => asContent(formatTime(iso, format)),
+    });
+    tools.push({
+        name: "clock.parseTime",
+        description: "解析 ISO 时间字符串为结构化字段",
+        inputSchema: { iso: z.string().min(1) },
+        handler: async ({ iso }) => asContent(parseTime(iso)),
+    });
+    // ============================================================
+    // profile (8 tools — get / upsert / markInactivityNudge / claimNudge /
+    //                   confirm_default / bindAlias / listMyChannels / createUser)
+    // ============================================================
+    tools.push({
+        name: "profile.get",
+        description: "获取用户 profile（含结构化约定）",
+        inputSchema: { user_id: z.string().optional() },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await profile.get(r.user_id));
+        },
+    });
+    tools.push({
+        name: "profile.upsert",
+        description: "创建或更新用户 profile（display_name / expectations / settings）。首次确认请用 profile.confirm_default。",
+        inputSchema: {
+            user_id: z.string().optional(),
+            display_name: z.string().optional(),
+            expectations: z.string().optional(),
+            settings: z
+                .object({})
+                .passthrough()
+                .optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await profile.upsert(r));
+        },
+    });
+    tools.push({
+        name: "profile.markInactivityNudge",
+        description: "MV-COACH-3 slice 2（防重复失效专用）：触发「5 天没记录轻触」问候后必调。" +
+            "专门写 settings.last_inactivity_nudge_at = now。" +
+            "⚠️ 不要用 profile.upsert 写这个字段——upsert 是 whole-replace 会清掉其它 settings key。" +
+            "本工具 deep-merge，只更新 last_inactivity_nudge_at 一个 key。",
+        inputSchema: {
+            user_id: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await profile.markInactivityNudge({ user_id: r.user_id }));
+        },
+    });
+    tools.push({
+        name: "profile.claimNudge",
+        description: "S40 slice 2（多 cron 并发 atomic 抢占）：nag fan-out 多渠道时用。" +
+            "window_minutes 内只有第一个调用赢（won=true），其它返回 won=false。" +
+            "**调用方必须看返回的 won 字段**：" +
+            "won=true → 输出问候；won=false → 输出 [SILENT]（已被其它 cron 抢先）。" +
+            "默认 window=5 分钟，覆盖 cron 启动间隔差。",
+        inputSchema: {
+            user_id: z.string().optional(),
+            window_minutes: z.number().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await profile.claimNudge({
+                user_id: r.user_id,
+                window_minutes: typeof rawInput.window_minutes === "number"
+                    ? rawInput.window_minutes
+                    : undefined,
+            }));
+        },
+    });
+    tools.push({
+        name: "profile.confirm_default",
+        description: "首次写入前确认默认用户：写入 user_profile，设置 display_name 与 default_confirmed_at。display_name 重名则拒绝。",
+        inputSchema: {
+            platform_user_id: z.string().min(1),
+            display_name: z.string().min(1),
+        },
+        handler: async (input) => asContent(await profileConfirm.confirmDefault(input)),
+    });
+    // ============================================================
+    // S40: cross-platform identity (bindAlias / listMyChannels)
+    // ============================================================
+    tools.push({
+        name: "profile.bindAlias",
+        description: "S40 跨平台身份层：把一个平台 chat_id 绑定到已有 libero 用户身份。" +
+            "场景：用户在新设备（如飞书）首次开口，主会话问『要和已有账号（如企微）合并吗』，得到肯定后调这个。" +
+            "libero_user_id 为空 = 首次绑定，自动建一个 libero_user_id。" +
+            "平台 chat_id 跟 libero_user_id 一对多关系（1 个真人 ↔ N 平台）。",
+        inputSchema: {
+            libero_user_id: z.string().optional(),
+            platform: z.enum(["wecom", "feishu", "weixin", "telegram", "discord", "signal", "unknown"]),
+            platform_user_id: z.string().min(1),
+            chat_id: z.string().optional(),
+            display_name: z.string().optional(),
+        },
+        handler: async (input) => {
+            const crypto = await import("node:crypto");
+            let lid = input.libero_user_id;
+            if (!lid) {
+                lid = `u_libero_${crypto.randomUUID().replace(/-/g, "").slice(0, 16)}`;
+                await identityRepo.createIdentity({
+                    libero_user_id: lid,
+                    display_name: input.display_name ?? input.platform_user_id.slice(0, 16),
+                });
+            }
+            else {
+                const existing = await identityRepo.getIdentity(lid);
+                if (!existing) {
+                    return errorContent(`libero_user_id not found: ${lid}`);
+                }
+            }
+            try {
+                await identityRepo.bindAlias({
+                    libero_user_id: lid,
+                    platform: input.platform,
+                    platform_user_id: input.platform_user_id,
+                    chat_id: input.chat_id,
+                });
+            }
+            catch (e) {
+                return errorContent(e.message);
+            }
+            const aliases = await identityRepo.listAliases(lid);
+            return asContent({ libero_user_id: lid, bound_aliases: aliases });
+        },
+    });
+    tools.push({
+        name: "profile.listMyChannels",
+        description: "S40 跨平台身份层：列出当前用户绑定的所有平台渠道。" +
+            "用途：nag fan-out（按渠道建独立 cron）、跨平台数据查询、身份确认。",
+        inputSchema: {
+            user_id: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            const lid = await resolveUserId(identityRepo, r.user_id);
+            const aliases = await identityRepo.listAliases(lid);
+            return asContent({
+                libero_user_id: lid,
+                channels: aliases.map((a) => ({
+                    platform: a.platform,
+                    platform_user_id: a.platform_user_id,
+                    chat_id: a.chat_id,
+                    bound_at: a.bound_at,
+                })),
+            });
+        },
+    });
+    tools.push({
+        name: "profile.createUser",
+        description: "S41 多用户建档：建立新 libero 用户（父母代管模式）。" +
+            "用户体感：「帮我建一个新用户」「我要给我儿子建档」时调用。" +
+            "返回 libero_user_id，建档后该 id 立即可用于 target_user_id。" +
+            "同一家长下同名孩子会复用已有档案并自动 setManager。" +
+            "可选绑定平台 alias（如果建档时已知 chat_id）。" +
+            "display_name 必填；platform 和 platform_user_id 必须同时给或同时不给。",
+        inputSchema: {
+            user_id: z.string().optional(),
+            display_name: z.string().min(1),
+            focus_areas: z.array(z.string()).optional(),
+            goals: z.string().optional(),
+            platform: z
+                .enum(["wecom", "feishu", "weixin", "telegram", "discord", "signal", "unknown"])
+                .optional(),
+            platform_user_id: z.string().optional(),
+            chat_id: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            try {
+                const r = await injector(rawInput);
+                if ("error" in r)
+                    return errorContent(r.error);
+                const result = await profile.createUser({
+                    user_id: r.user_id,
+                    display_name: r.display_name,
+                    focus_areas: r.focus_areas,
+                    goals: r.goals,
+                    platform: r.platform,
+                    platform_user_id: r.platform_user_id,
+                    chat_id: r.chat_id,
+                });
+                return asContent(result);
+            }
+            catch (e) {
+                return errorContent(e.message);
+            }
+        },
+    });
+    tools.push({
+        name: "profile.listAllUsers",
+        description: "S43 多用户扫描：列出所有 libero 用户（libero_user_id + display_name）。" +
+            "用途：cron 扫描（每 30min）跑所有用户的状态升级和主动询问，不靠 LLM 从上下文猜。" +
+            "⚠️ 仅 cron-session 调用，普通对话不要用。",
+        inputSchema: {},
+        handler: async () => {
+            try {
+                const result = await profile.listAllUsers();
+                return asContent({ users: result });
+            }
+            catch (e) {
+                return errorContent(e.message);
+            }
+        },
+    });
+    tools.push({
+        name: "profile.getManager",
+        description: "S44 代管转发：查某用户的代管人（managed_by + 代管人 display_name）。" +
+            "用途：扫描 cron 发现用户没自己渠道时，查 managed_by 把追问发给代管人。" +
+            "返回 managed_by=null 表示该用户没代管人（普通独立用户）。",
+        inputSchema: {
+            user_id: z.string().min(1),
+        },
+        handler: async (rawInput) => {
+            try {
+                const result = await profile.getManager({ user_id: rawInput.user_id });
+                return asContent(result);
+            }
+            catch (e) {
+                return errorContent(e.message);
+            }
+        },
+    });
+    tools.push({
+        name: "profile.setManager",
+        description: "S44 代管转发：设置或清除某用户的代管人。" +
+            "用法：profile.setManager({ user_id: '<被代管人>', managed_by: '<代管人 libero_user_id>' })。" +
+            "managed_by=null 清除代管关系；非 null 必须指向存在的 libero_user_id（FK 校验）。" +
+            "典型场景：父母给孩子建账户后，profile.setManager({ user_id: '<孩子>', managed_by: '<父母>' })。",
+        inputSchema: {
+            user_id: z.string().min(1),
+            managed_by: z.string().nullable(),
+        },
+        handler: async (rawInput) => {
+            try {
+                const result = await profile.setManager({
+                    user_id: rawInput.user_id,
+                    managed_by: rawInput.managed_by,
+                });
+                return asContent(result);
+            }
+            catch (e) {
+                return errorContent(e.message);
+            }
+        },
+    });
+    // ============================================================
+    // reminder (6 tools — S11)
+    // ============================================================
+    tools.push({
+        name: "reminder.create",
+        description: "⚠️ 仅写 DB，不主动推送（libero-mcp 无 background sender）。" +
+            "在 hermes 等有 cronjob 工具的平台上，用户要'X 时间提醒我 Y'请调宿主 cronjob（action=create, deliver=origin），不要用本工具。" +
+            "本工具仅用于：① 无 cron 能力的平台兜底；② 查询场景配合 getDue/getMissed。",
+        inputSchema: {
+            user_id: z.string().optional(),
+            target_user_id: z.string().min(1).optional(),
+            content: z.string().min(1),
+            remind_at: z.string().min(1),
+            channel: z.string().optional(),
+            timeblock_id: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await reminder.create(r));
+        },
+    });
+    tools.push({
+        name: "reminder.getDue",
+        description: "获取到期且待发送的提醒列表",
+        inputSchema: {
+            user_id: z.string().optional(),
+            until: z.string().optional(),
+        },
+        handler: async (input) => asContent(await reminder.getDueReminders(input)),
+    });
+    tools.push({
+        name: "reminder.getNextDue",
+        description: "获取下一条待发送提醒的时间",
+        inputSchema: {
+            user_id: z.string().optional(),
+        },
+        handler: async (input) => asContent(await reminder.getNextDue(input)),
+    });
+    tools.push({
+        name: "reminder.getMissed",
+        description: "获取过期但未送达的提醒（被动补发用）",
+        inputSchema: {
+            user_id: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await reminder.getMissedReminders({ user_id: r.user_id }));
+        },
+    });
+    tools.push({
+        name: "reminder.markSent",
+        description: "标记提醒为已发送（幂等）",
+        inputSchema: { id: z.string().min(1) },
+        handler: async ({ id }) => asContent(await reminder.markSent(id)),
+    });
+    tools.push({
+        name: "reminder.cancel",
+        description: "取消一条提醒（幂等）",
+        inputSchema: { id: z.string().min(1) },
+        handler: async ({ id }) => asContent(await reminder.cancelReminder(id)),
+    });
+    // ============================================================
+    // scheduler (3 tools — S27, reuses timeblockRepo)
+    // ============================================================
+    tools.push({
+        name: "scheduler.createSchedule",
+        description: "创建一个日程（planned 时间块）。" +
+            "⚠️ MV-COACH-3 Slice 4 v2 教练闭环（用户主权模型）：建完 schedule 后，**必须**在同一回复里完成：" +
+            "① 调 cronjob(action=create, deliver=origin) 建开工 cron（schedule=日程开始时间），cron prompt 必须用 libero-coach skill 的'开工 cron 标准 prompt 模板'——**不允许自创结构**。" +
+            "② 那条标准 prompt 里写死了 3 步：推提醒 + 调 timeblock.update(status=**unverified**，不是 in_progress) + 建追问 cron（时间动态算：有耗时→过半；无耗时→+30min）。" +
+            "③ 顺带问用户'要不要每天 22:00 做个简短复盘？'（B 类推送必须先问再建）。" +
+            "关键：状态机用户主权——LLM 只能到点标 unverified 等用户核实，**不能擅自升级到 completed**。" +
+            "详见 libero-coach skill 的'推送抓手 + 状态机一条龙'段。",
+        inputSchema: {
+            user_id: z.string().optional(),
+            target_user_id: z.string().min(1).optional(),
+            title: z.string().min(1),
+            category_id: z.string().optional(),
+            start_time: z.string(),
+            end_time: z.string(),
+            duration_minutes: z.number().optional(),
+            rating: z.number().min(1).max(5).optional(),
+            rating_reason: z.string().optional(),
+            notes: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await scheduler.createSchedule(r));
+        },
+    });
+    tools.push({
+        name: "scheduler.listSchedules",
+        description: "内部工具：查询 planned 日程块用于排程冲突检查。" +
+            "⚠️ 用户「看今天/看日程/复盘/在干啥」请调 schedule.timeline（含矩阵+表格+全状态视图，不要调本工具）。" +
+            "本工具仅用于排程编排时的内部查询。",
+        inputSchema: {
+            user_id: z.string().optional(),
+            from: z.string().optional(),
+            to: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await scheduler.listSchedules(r));
+        },
+    });
+    tools.push({
+        name: "scheduler.checkConflict",
+        description: "检查时间段是否与已有日程冲突",
+        inputSchema: {
+            user_id: z.string().optional(),
+            start_time: z.string(),
+            end_time: z.string(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await scheduler.checkConflict(r));
+        },
+    });
+    // ============================================================
+    // scheduler MV-COACH-5 (2 tools — 3F 架构意图 API)
+    // ============================================================
+    tools.push({
+        name: "scheduler.setIntent",
+        description: "MV-COACH-5 3F 架构 §4.1：注册一个意图（提前提醒/追问/复盘/一次性提醒）。" +
+            "脑层（skill）调这个，不直接调宿主的 cronjob——通用核心记意图到 DB，调宿主适配层翻译成该平台机制。" +
+            "hermes 上 → 翻译成 cron job；无推送能力的平台 → 标 pending 等用户开口补推（slice 4 实装）。" +
+            "⚠️ slice 1 纯加法：现有 skill 继续直调 cronjob（v4/v5 路径不破坏），slice 3 才迁移 skill 调本工具。" +
+            "intent_type ∈ {pre_start_reminder, missed_check, daily_review, one_off_reminder}；" +
+            "pre_start/missed_check 必填 schedule_id。trigger.kind ∈ {relative, absolute, recurring}。",
+        inputSchema: {
+            user_id: z.string().optional(),
+            target_user_id: z.string().min(1).optional(),
+            intent_type: z.enum([
+                "pre_start_reminder",
+                "missed_check",
+                "daily_review",
+                "one_off_reminder",
+            ]),
+            schedule_id: z.string().optional(),
+            trigger: z.object({
+                kind: z.enum(["relative", "absolute", "recurring"]),
+                offset: z.string().optional(),
+                relative_to: z.enum(["schedule.start", "now"]).optional(),
+                at: z.string().optional(),
+                cron_expr: z.string().optional(),
+            }),
+            action_prompt: z.string().min(1),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            try {
+                const result = await scheduler.setIntent({
+                    user_id: r.user_id,
+                    intent_type: rawInput.intent_type,
+                    schedule_id: rawInput.schedule_id,
+                    trigger: rawInput.trigger,
+                    action_prompt: rawInput.action_prompt,
+                });
+                return asContent(result);
+            }
+            catch (e) {
+                return errorContent(e.message);
+            }
+        },
+    });
+    tools.push({
+        name: "scheduler.cancelIntent",
+        description: "MV-COACH-5 3F 架构 §4.2：撤销一个意图（用户删日程时连带撤提醒/追问）。" +
+            "intent_id 必填（从 setIntent 返回值拿）。",
+        inputSchema: {
+            intent_id: z.string().min(1),
+        },
+        handler: async (rawInput) => {
+            try {
+                const result = await scheduler.cancelIntent({
+                    intent_id: rawInput.intent_id,
+                });
+                return asContent(result);
+            }
+            catch (e) {
+                return errorContent(e.message);
+            }
+        },
+    });
+    // ============================================================
+    // task (6 tools — S29 P2-3 + 事一 draft/commit, takes raw db)
+    // ============================================================
+    tools.push({
+        name: "task.create",
+        description: "建单个独立任务（不挂任何 timeblock）。⚠️ 拆解请用 decompose.split，本工具一次只能建一个任务、不能建子任务。S46 支持 difficulty（easy/medium/hard，默认 medium）+ priority（high/medium/low，默认 medium），用于'快速启动+峰终'智能排程。",
+        // S33 v3: 用 z.object().strict() 显式拒 parent_id（zod 默认 strip 不报错，
+        // 严格模式让多余键触发 safeParse 失败 → MCP 返回 isError）。
+        // 底层 createTask 仍保留 parent_id 能力（task.test.ts 单测不破）。
+        inputSchema: z
+            .object({
+            user_id: z.string().optional(),
+            target_user_id: z.string().min(1).optional(),
+            title: z.string().min(1),
+            est_minutes: z.number().optional(),
+            difficulty: z.enum(["easy", "medium", "hard"]).optional(),
+            priority: z.enum(["high", "medium", "low"]).optional(),
+        })
+            .strict(),
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await task.createTask(r));
+        },
+    });
+    tools.push({
+        name: "task.get",
+        description: "按 id 获取任务（含递归子树）",
+        inputSchema: { id: z.string().min(1) },
+        handler: async ({ id }) => asContent(await task.getTask(id)),
+    });
+    tools.push({
+        name: "task.list",
+        description: "列出任务（parent_id=null 仅根；给定则该父的子；省略则全部）",
+        inputSchema: {
+            user_id: z.string().optional(),
+            target_user_id: z.string().min(1).optional(),
+            parent_id: z.string().nullable().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await task.listTasks(r));
+        },
+    });
+    tools.push({
+        name: "task.update",
+        description: "更新任务（title/est_minutes/status/difficulty/priority；状态机校验非法流转）",
+        inputSchema: {
+            id: z.string().min(1),
+            title: z.string().optional(),
+            est_minutes: z.number().optional(),
+            status: z.string().optional(),
+            difficulty: z.enum(["easy", "medium", "hard"]).optional(),
+            priority: z.enum(["high", "medium", "low"]).optional(),
+        },
+        handler: async ({ id, ...rest }) => {
+            const updated = await task.updateTask(id, rest);
+            // INT-ap-rewards：任务状态机流转到 done = 任务实绩
+            if (rest.status === "done") {
+                await rewardHook(updated.user_id, "task", `task:${id}`);
+            }
+            return asContent(updated);
+        },
+    });
+    tools.push({
+        name: "task.linkTimeblock",
+        description: "把任务关联到一个时间块（子任务开工执行时）",
+        inputSchema: {
+            task_id: z.string().min(1),
+            block_id: z.string().min(1),
+        },
+        handler: async ({ task_id, block_id }) => asContent(await task.linkTimeblock(task_id, block_id)),
+    });
+    tools.push({
+        name: "task.updateDifficulty",
+        description: "S46: 仅更新 task 的 difficulty（easy/medium/hard）或 priority（high/medium/low）。用户主动调整时用，默认 medium。用于'快速启动+峰终'智能排程。",
+        inputSchema: {
+            task_id: z.string().min(1),
+            difficulty: z.enum(["easy", "medium", "hard"]).optional(),
+            priority: z.enum(["high", "medium", "low"]).optional(),
+        },
+        handler: async ({ task_id, difficulty, priority }) => asContent(await task.updateDifficulty(task_id, { difficulty, priority })),
+    });
+    tools.push({
+        name: "task.findPlan",
+        description: "按事件名 exact-match 查拆解计划：返回根任务 + 第一块未完成子任务（record 开工时链 task_id，驱动闭环正反馈）",
+        inputSchema: {
+            user_id: z.string().optional(),
+            title: z.string().min(1),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await task.findPlan(r));
+        },
+    });
+    // S33 v3: task.draftPlan / task.commitPlan 从 MCP 工具列表移除（不再暴露给 mimo）。
+    // 拆解唯一入口 = decompose.split（见下方 decompose 段）。
+    // 底层 draftPlan/commitPlan 方法保留在 mcp/src/task/index.ts（被 decompose.split 复用 + task.test.ts 单测覆盖）。
+    // ============================================================
+    // decompose (1 tool — S33 v3：动作分离重构)
+    // decompose.split = 拆解唯一入口。状态机强制 draft→confirm→commit。
+    // 错误返回 isError content（不 throw），避 hermes 熔断器（v2 实证坑）。
+    // ============================================================
+    tools.push({
+        name: "decompose.split",
+        description: "拆解 timeblock 为结构化子任务树（拆解唯一入口）。第一次调用出方案（不写库），第二次带 confirm_token 落地。状态机强制 draft→confirm→commit。⚠️ 拆子任务请用本工具，不要用 task.create。",
+        inputSchema: {
+            user_id: z.string().optional(),
+            timeblock_id: z.string().min(1),
+            children: z
+                .array(z.object({
+                title: z.string().min(1),
+                est_minutes: z.number().optional(),
+            }))
+                .min(1),
+            confirm_token: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            const result = await task.splitDecompose(r);
+            // DecomposeErrorResult → isError content（不 throw，避 hermes 熔断器）
+            if ("ok" in result && result.ok === false) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result),
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            return asContent(result);
+        },
+    });
+    // ============================================================
+    // ap (3 tools — INT-AP-tools R2: credit / balance / spend)
+    // ============================================================
+    tools.push({
+        name: "ap.credit",
+        description: "给用户 AP 账入账（时间管理动作换算后的结果，或手动投喂）",
+        inputSchema: {
+            user_id: z.string().optional(),
+            source: z.string().min(1),
+            amount: z.number().int().positive(),
+            idempotency_key: z.string().min(1).optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await ap.credit(r));
+        },
+    });
+    tools.push({
+        name: "ap.balance",
+        description: "查询用户当前 AP 余额（只读）",
+        inputSchema: {
+            user_id: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await ap.balance(r));
+        },
+    });
+    tools.push({
+        name: "ap.spend",
+        description: "出击时带出 AP：缺省 amount = 带出当前全部余额（B2'，一次往返）；显式 amount 时余额不足返回 forbidden",
+        inputSchema: {
+            user_id: z.string().optional(),
+            amount: z.number().int().positive().optional(),
+            idempotency_key: z.string().min(1).optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            // B2' 带出全部：缺省 amount = 当前余额（省一次客户端 refresh 往返）
+            if (r.amount === undefined) {
+                const bal = (await ap.balance(r)).balance;
+                if (bal <= 0)
+                    return asContent({ balance: 0, spent: 0 }); // 空钱包：无操作，幂等键不消耗
+                const all = await ap.spend({ ...r, amount: bal });
+                if (!all.ok) {
+                    return errorContent(`insufficient AP (balance=${all.balance})`, "forbidden");
+                }
+                return asContent({ balance: all.balance, spent: all.spent });
+            }
+            const result = await ap.spend(r);
+            if (!result.ok) {
+                return errorContent(`insufficient AP (balance=${result.balance})`, "forbidden");
+            }
+            return asContent({ balance: result.balance, spent: result.spent });
+        },
+    });
+    tools.push({
+        name: "rewards.status",
+        description: "INT-ap-rewards：本期各实绩动作（计时/日程/任务/复盘）已计次数与下次收益，只读（悬赏呈现层用）",
+        inputSchema: {
+            user_id: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await ctx.repos.apRepo.rewardStatus(r.user_id));
+        },
+    });
+    // ── rewards 悬赏（方案 A）+ 复盘完成信号 ──
+    tools.push({
+        name: "bounties.status",
+        description: "INT-ap-rewards 悬赏：今日 3 个日常任务（计时×1/时间块×3/复盘×1）进度与完成态，只读（营地任务板/脑层发布用）",
+        inputSchema: {
+            user_id: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            return asContent(await ctx.repos.apRepo.bountiesStatus(r.user_id));
+        },
+    });
+    tools.push({
+        name: "review.complete",
+        description: "INT-ap-rewards：复盘完成信号——脑层在一次复盘对话收尾时调用，记一次复盘实绩（周曲线 5,3,1→保底1；当日悬赏 复盘×1）",
+        inputSchema: {
+            user_id: z.string().optional(),
+            notes: z.string().optional(),
+        },
+        needsUserIdInjection: true,
+        handler: async (rawInput) => {
+            const r = await injector(rawInput);
+            if ("error" in r)
+                return errorContent(r.error);
+            void r.notes; // 预留：复盘摘要留档（不进奖励逻辑）
+            const result = await ctx.repos.apRepo.recordRewardEvent({
+                user_id: r.user_id,
+                action_type: "review",
+                event_id: `review:${Date.now().toString(36)}-${Math.floor(Math.random() * 1e6).toString(36)}`,
+            });
+            return asContent(result ?? { nth: 0, amount: 0 });
+        },
+    });
+    return tools;
+}
+/**
+ * Shared runtime for MCP + REST: same repos, same registry, same sqlite.
+ * MC-0b REST adapter calls handlers on this registry; must not duplicate business logic.
+ */
+export function createToolRuntime(db) {
+    // MV-COACH-3 Slice 2: resolve default user_id once at server build
+    const defaultUser = resolveDefaultUserId({ db, env: process.env });
+    logResolvedDefaultUserId(defaultUser);
+    const injector = makeUserIdInjector(defaultUser.userId, db);
+    const repos = createRepos(db);
+    const categories = createCategoryTools(repos.categoryRepo);
+    const tb = createTimeBlockTools(repos.timeblockRepo, db);
+    const stats = createStatsTools(repos.statsRepo);
+    const matrix = createMatrixTools(repos.statsRepo);
+    const timeline = createTimelineTools(repos.timelineRepo);
+    const timer = createTimerTools(repos.timerRepo, repos.timeblockRepo, db);
+    const profile = createProfileTools(repos.profileRepo, repos.identityRepo);
+    const profileConfirm = createProfileConfirmTools(db);
+    const reminder = createReminderTools(repos.reminderRepo, undefined, db);
+    const scheduler = createSchedulerTools(repos.timeblockRepo, repos.reminderRepo, repos.categoryRepo, selectAdapter(createAdaptersWithDb(db)), db);
+    const task = createTaskTools(db);
+    const knowledgeRepo = new FsYamlKnowledgeRepo();
+    const coachmod = createCoachModTools(knowledgeRepo, db);
+    const ap = createApTools(repos.apRepo);
+    const ctx = {
+        repos,
+        categories,
+        tb,
+        stats,
+        matrix,
+        timeline,
+        timer,
+        profile,
+        profileConfirm,
+        reminder,
+        scheduler,
+        task,
+        coachmod,
+        ap,
+        injector,
+        db,
+    };
+    return { registry: buildToolRegistry(ctx) };
+}
+/**
+ * Build the libero MCP server on a given DB connection.
+ * Tools throw Error on business violations; handlers let them propagate —
+ * the SDK turns thrown errors into MCP tool errors (isError) preserving the message.
+ */
+export function buildServer(db) {
+    const { registry } = createToolRuntime(db);
+    // instructions 必须放在第 2 参 ServerOptions（不是 serverInfo）—— SDK 只从 options 读
+    const server = new McpServer({ name: "libero-mcp", version: "0.2.3" }, { instructions: buildServerInstructions() });
+    for (const tool of registry) {
+        server.registerTool(tool.name, { description: tool.description, inputSchema: tool.inputSchema }, tool.handler);
+    }
+    return server;
+}