libero3 0.3.0

package/dist/mcp/src/repo/types.js

@@ -0,0 +1,4 @@
+// ============================================================
+// Domain types — shared by tools and repos
+// ============================================================
+export {};

package/dist/mcp/src/rest/app.js

@@ -0,0 +1,121 @@
+/**
+ * MC-0b REST adapter: HTTP ↔ ToolModule registry. No business logic copy.
+ * MC-CHAT: POST /api/v1/chat hangs off the same app + auth.
+ */
+import { Hono } from "hono";
+import { resolveBearer } from "./tokens.js";
+import { chatRequestBodySchema } from "../../contract/v1/rest.js";
+import { invokeRegisteredTool } from "./invoke-tool.js";
+import { issueShortToken } from "./short-token.js";
+import { runChatTurn } from "../chat/loop.js";
+function errorJson(code, message, status) {
+    return { body: { ok: false, error: { code, message } }, status };
+}
+export function createRestApp(opts) {
+    const byName = new Map(opts.registry.map((t) => [t.name, t]));
+    const READ_ALLOWED_TOOLS = new Set(["ap.balance"]);
+    const nowSec = () => Math.floor((opts.now ? opts.now() : Date.now()) / 1000);
+    const resolve = (auth) => resolveBearer(auth, { tokenMap: opts.tokenMap, linkSecret: opts.linkSecret, nowSec: nowSec() });
+    const linkBase = opts.linkBaseUrl ?? "https://homm.kuibu.studio/camp.html";
+    const ttlSec = opts.ttlSec ?? 86400;
+    const mintLink = opts.linkSecret
+        ? (userId) => `${linkBase}?t=${issueShortToken({ userId, scope: "read", ttlSec }, opts.linkSecret, nowSec())}`
+        : undefined;
+    const app = new Hono();
+    app.get("/api/v1/health", (c) => c.json({ ok: true }));
+    app.post("/api/v1/chat", async (c) => {
+        const bearer = resolve(c.req.header("Authorization"));
+        if (!bearer) {
+            const e = errorJson("unauthorized", "missing or invalid bearer token", 401);
+            return c.json(e.body, e.status);
+        }
+        if (bearer.scope === "read") {
+            const e = errorJson("forbidden", "token scope is read-only", 403);
+            return c.json(e.body, e.status);
+        }
+        const userId = bearer.userId;
+        if (!opts.chatLlm) {
+            const e = errorJson("unavailable", "chat model is not configured (set LIBERO_CHAT_BASE_URL, LIBERO_CHAT_API_KEY, LIBERO_CHAT_MODEL)", 503);
+            return c.json(e.body, e.status);
+        }
+        let raw = {};
+        try {
+            const text = await c.req.text();
+            if (text.trim())
+                raw = JSON.parse(text);
+        }
+        catch {
+            const e = errorJson("invalid_input", "body must be JSON object", 400);
+            return c.json(e.body, e.status);
+        }
+        const parsed = chatRequestBodySchema.safeParse(raw);
+        if (!parsed.success) {
+            const e = errorJson("invalid_input", parsed.error.issues.map((i) => i.message).join("; ") || "invalid input", 400);
+            return c.json(e.body, e.status);
+        }
+        try {
+            const turn = await runChatTurn({
+                llm: opts.chatLlm,
+                registry: opts.registry,
+                userId,
+                message: parsed.data.message,
+                conversationKey: `rest:${userId}`,
+                mintLink,
+            });
+            return c.json({
+                ok: true,
+                reply: turn.reply,
+                tools_called: turn.toolsCalled,
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : "llm error";
+            const e = errorJson("llm_error", msg, 502);
+            return c.json(e.body, e.status);
+        }
+    });
+    app.post("/api/v1/tools/:toolName", async (c) => {
+        const bearer = resolve(c.req.header("Authorization"));
+        if (!bearer) {
+            const e = errorJson("unauthorized", "missing or invalid bearer token", 401);
+            return c.json(e.body, e.status);
+        }
+        const toolName = c.req.param("toolName");
+        if (bearer.scope === "read" && !READ_ALLOWED_TOOLS.has(toolName)) {
+            const e = errorJson("forbidden", "token scope is read-only", 403);
+            return c.json(e.body, e.status);
+        }
+        const userId = bearer.userId;
+        let raw = {};
+        try {
+            const text = await c.req.text();
+            if (text.trim())
+                raw = JSON.parse(text);
+        }
+        catch {
+            const e = errorJson("invalid_input", "body must be JSON object", 400);
+            return c.json(e.body, e.status);
+        }
+        if (raw === null || typeof raw !== "object" || Array.isArray(raw)) {
+            const e = errorJson("invalid_input", "body must be JSON object", 400);
+            return c.json(e.body, e.status);
+        }
+        try {
+            const invoked = await invokeRegisteredTool({
+                byName,
+                toolName,
+                rawArgs: raw,
+                userId,
+            });
+            if (!invoked.ok) {
+                return c.json({ ok: false, error: { code: invoked.code, message: invoked.message } }, invoked.httpStatus);
+            }
+            return c.json({ ok: true, data: invoked.data });
+        }
+        catch (err) {
+            const e = errorJson("internal", err instanceof Error ? err.message : "internal error", 500);
+            return c.json(e.body, e.status);
+        }
+    });
+    return app;
+}

package/dist/mcp/src/rest/invoke-tool.js

@@ -0,0 +1,98 @@
+/**
+ * Shared tool invoke for REST POST /tools/:name and the chat loop.
+ * No business logic — zod + handler + unwrap MCP content.
+ */
+import { z } from "zod";
+function inputToZod(schema) {
+    if (schema && typeof schema === "object" && "safeParse" in schema) {
+        return schema;
+    }
+    return z.object(schema);
+}
+export function schemaHasUserId(schema) {
+    if (schema && typeof schema === "object" && !("safeParse" in schema)) {
+        return Object.prototype.hasOwnProperty.call(schema, "user_id");
+    }
+    const shape = schema.shape;
+    return !!(shape && Object.prototype.hasOwnProperty.call(shape, "user_id"));
+}
+export function unwrapMcpResult(result) {
+    if (!result || typeof result !== "object") {
+        return { isError: false, data: result };
+    }
+    const r = result;
+    const text = r.content?.[0]?.text;
+    if (typeof text === "string") {
+        try {
+            return { isError: !!r.isError, data: JSON.parse(text) };
+        }
+        catch {
+            return { isError: !!r.isError, data: text };
+        }
+    }
+    return { isError: !!r.isError, data: result };
+}
+export function invokeRegisteredTool(opts) {
+    const tool = opts.byName.get(opts.toolName);
+    if (!tool) {
+        return {
+            ok: false,
+            code: "not_found",
+            message: `unknown tool: ${opts.toolName}`,
+            httpStatus: 404,
+        };
+    }
+    const args = { ...opts.rawArgs };
+    if (tool.needsUserIdInjection || schemaHasUserId(tool.inputSchema)) {
+        if (typeof args.user_id === "string" && args.user_id !== opts.userId) {
+            return {
+                ok: false,
+                code: "forbidden",
+                message: "user_id does not match bearer token",
+                httpStatus: 403,
+            };
+        }
+        args.user_id = opts.userId;
+    }
+    const parsed = inputToZod(tool.inputSchema).safeParse(args);
+    if (!parsed.success) {
+        return {
+            ok: false,
+            code: "invalid_input",
+            message: parsed.error.issues.map((i) => i.message).join("; ") || "invalid input",
+            httpStatus: 400,
+        };
+    }
+    return Promise.resolve(tool.handler(parsed.data))
+        .then((result) => {
+        const unwrapped = unwrapMcpResult(result);
+        if (unwrapped.isError) {
+            const data = unwrapped.data;
+            const msg = data &&
+                typeof data === "object" &&
+                "error" in data &&
+                typeof data.error === "string"
+                ? data.error
+                : "tool error";
+            const code = data &&
+                typeof data === "object" &&
+                "code" in data &&
+                data.code === "forbidden"
+                ? "forbidden"
+                : "tool_error";
+            return {
+                ok: false,
+                code,
+                message: msg,
+                httpStatus: (code === "forbidden" ? 403 : 400),
+            };
+        }
+        return { ok: true, data: unwrapped.data };
+    })
+        .catch((err) => ({
+        ok: false,
+        code: "internal",
+        message: err instanceof Error ? err.message : "internal error",
+        httpStatus: 500,
+    }));
+}

package/dist/mcp/src/rest/short-token.js

@@ -0,0 +1,38 @@
+/**
+ * 无状态短 token：v1.<base64url(payload)>.<base64url(hmac-sha256)>
+ * payload = { u: userId, s: scope, e: expEpochSec }。秘钥只从调用方传入，绝不入日志。
+ */
+import { createHmac, timingSafeEqual } from "node:crypto";
+const PREFIX = "v1";
+function sign(body, secret) {
+    return createHmac("sha256", secret).update(`${PREFIX}.${body}`).digest().toString("base64url");
+}
+export function issueShortToken(input, secret, nowSec = Math.floor(Date.now() / 1000)) {
+    const payload = { u: input.userId, s: input.scope, e: nowSec + input.ttlSec };
+    const body = Buffer.from(JSON.stringify(payload), "utf8").toString("base64url");
+    return `${PREFIX}.${body}.${sign(body, secret)}`;
+}
+export function verifyShortToken(token, secret, nowSec = Math.floor(Date.now() / 1000)) {
+    const parts = token.split(".");
+    if (parts.length !== 3 || parts[0] !== PREFIX)
+        return null;
+    const [, body, sig] = parts;
+    const expected = sign(body, secret);
+    const a = Buffer.from(sig);
+    const b = Buffer.from(expected);
+    if (a.length !== b.length || !timingSafeEqual(a, b))
+        return null;
+    let payload;
+    try {
+        payload = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
+    }
+    catch {
+        return null;
+    }
+    const { u, s, e } = payload;
+    if (typeof u !== "string" || (s !== "read" && s !== "full") || typeof e !== "number")
+        return null;
+    if (e <= nowSec)
+        return null;
+    return { userId: u, scope: s, exp: e };
+}

package/dist/mcp/src/rest/tokens.js

@@ -0,0 +1,55 @@
+export function parseRestTokens(env = process.env) {
+    const raw = env.LIBERO_REST_TOKENS;
+    if (!raw || !raw.trim()) {
+        throw new Error("LIBERO_REST_TOKENS is required (JSON object { token: libero_user_id })");
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error("LIBERO_REST_TOKENS must be valid JSON");
+    }
+    if (parsed === null ||
+        typeof parsed !== "object" ||
+        Array.isArray(parsed)) {
+        throw new Error("LIBERO_REST_TOKENS must be a JSON object");
+    }
+    const map = {};
+    for (const [token, userId] of Object.entries(parsed)) {
+        if (!token || typeof userId !== "string" || !userId.trim()) {
+            throw new Error("LIBERO_REST_TOKENS entries must be token → non-empty user id");
+        }
+        map[token] = userId;
+    }
+    if (Object.keys(map).length === 0) {
+        throw new Error("LIBERO_REST_TOKENS must contain at least one token");
+    }
+    return map;
+}
+export function userIdForBearer(authorization, tokenMap) {
+    if (!authorization)
+        return null;
+    const m = /^Bearer\s+(\S+)$/i.exec(authorization.trim());
+    if (!m)
+        return null;
+    return tokenMap[m[1]] ?? null;
+}
+import { verifyShortToken } from "./short-token.js";
+export function resolveBearer(authorization, opts) {
+    if (!authorization)
+        return null;
+    const m = /^Bearer\s+(\S+)$/i.exec(authorization.trim());
+    if (!m)
+        return null;
+    const token = m[1];
+    const mapped = opts.tokenMap[token];
+    if (mapped)
+        return { userId: mapped, scope: "full" };
+    if (opts.linkSecret) {
+        const v = verifyShortToken(token, opts.linkSecret, opts.nowSec);
+        if (v)
+            return { userId: v.userId, scope: v.scope };
+    }
+    return null;
+}

package/dist/mcp/src/scheduler/index.js

@@ -0,0 +1,319 @@
+import { effectiveUserId } from "../profile-helpers.js";
+// ── S32 reply_contract: trigger logic + schema ──
+// 跟 SKILL §332-335 同仓演进：改触发条件 = 改这里 + rebuild MCP，不改 plugin。
+/** Slot 模板（数据驱动，改措辞不重 build plugin）。 */
+const ASK_DECOMPOSE_SLOT = {
+    cue_pattern: "拆成|帮你拆|要不要.*拆|拆解",
+    append_if_missing: "这段时间挺长，要不要我帮你拆成几个能上手的部分？",
+};
+const MEETING_KEYWORDS = /开会|站会|周会|sync|1on1|会议|meeting/is;
+const EXAM_KEYWORDS = /考试|测验|备考|exam/is;
+const TRIGGER_CATEGORIES = new Set(["工作", "学习", "创作"]);
+/**
+ * 从标题关键词推断分类名。返回 TRIGGER_CATEGORIES 中的值或 null。
+ * ponytail: 关键词覆盖不全（只覆盖高频表达），但作为后备够用。
+ * 后续可迭代到 MCP inputSchema 加 category_name 参数 + skill 必传。
+ */
+function inferCategoryFromTitle(title) {
+    // 工作类关键词
+    if (/写代码|编码|码代码|debug|code\s?review|修bug|重构|写脚本|跑测试|联调|写功能|开发|编程|写程序|写插件|写模块|写接口|写服务|写新功能|写报告|写文档|写方案|写计划|写总结/.test(title)) {
+        return "工作";
+    }
+    // 创作类关键词
+    if (/剪|拍|vlog|视频|创作|画|设计|写文章|写博客|写小说|写故事|写歌|编曲|录音|直播|做图|修图|剪辑|后期/.test(title)) {
+        return "创作";
+    }
+    // 学习类关键词
+    if (/学习|看书|复习|预习|刷题|做题|练习|背单词|学|读论文|看教程|上网课|培训|读书会/.test(title)) {
+        return "学习";
+    }
+    return null;
+}
+/**
+ * 判定建块回复是否该含 ask_decompose slot（S32 §2.2）。
+ * 三条件：category_name ∈ {工作,学习,创作} && duration > 60min && 非会议非考试。
+ *
+ * §4.5 静默失败声明：category_name 缺失且无 categoryRepo 时返回 false（向后兼容，不报错）。
+ * 方案 B：当 category_name 缺失时，通过 categoryRepo 从 category_id resolve 名字。
+ * ponytail: 方案 C — category 都拿不到时，用标题关键词后备推断（覆盖 90% 漏触发）。
+ */
+export async function shouldAskDecompose(input, categoryRepo) {
+    // 优先用 input.category_name（向后兼容，万一调用方传了）
+    let categoryName = input.category_name;
+    if (!categoryName && categoryRepo && input.category_id) {
+        const cat = await categoryRepo.getById(input.category_id);
+        categoryName = cat?.name;
+    }
+    // ponytail: 标题关键词后备——AI 不传 category 时从 title 推断
+    if (!categoryName) {
+        const inferred = inferCategoryFromTitle(input.title);
+        if (inferred)
+            categoryName = inferred;
+    }
+    if (!categoryName || !TRIGGER_CATEGORIES.has(categoryName))
+        return false;
+    const durationMin = (new Date(input.end_time).getTime() - new Date(input.start_time).getTime()) /
+        60_000;
+    if (durationMin <= 60)
+        return false;
+    if (MEETING_KEYWORDS.test(input.title) || EXAM_KEYWORDS.test(input.title))
+        return false;
+    return true;
+}
+/**
+ * Subtract `minutes` from an ISO-8601 timestamp string.
+ * Pure string math — no Date timezone drift.
+ */
+function subtractMinutes(iso, minutes) {
+    const ms = new Date(iso).getTime() - minutes * 60_000;
+    return new Date(ms).toISOString();
+}
+export function createSchedulerTools(repo, reminderRepo, categoryRepo, 
+/**
+ * MV-COACH-5 slice 1: setIntent/cancelIntent 用的宿主适配层。
+ * 可选——不传则 setIntent 写 DB status=pending（降级路径）。
+ */
+activeAdapter, 
+/**
+ * MV-COACH-5 slice 1: raw DB 句柄，用于直接写 reminders 表的 intent_* 列
+ * （reminderRepo.create 不认 intent_* 字段也不接 cron_expr 占位 remind_at）。
+ */
+intentDb) {
+    return {
+        async createSchedule(input) {
+            // Reuse timeblock.create validation
+            if (!input.title || input.title.trim() === "") {
+                throw new Error("事件名不能为空");
+            }
+            if (input.start_time > input.end_time) {
+                throw new Error("开始时间不能晚于结束时间");
+            }
+            const ledgerUserId = effectiveUserId(input);
+            const userExists = await repo.userExists(ledgerUserId);
+            if (!userExists) {
+                throw new Error("用户不存在");
+            }
+            const existing = await repo.findExactWindow({
+                user_id: ledgerUserId,
+                title: input.title,
+                start: input.start_time,
+                end: input.end_time,
+                status: "planned",
+            });
+            if (existing) {
+                return { ...existing, reply_contract: { required_slots: [] } };
+            }
+            // Force status='planned' — schedules are always planned
+            const block = await repo.create({
+                ...input,
+                user_id: ledgerUserId,
+                status: "planned",
+            });
+            // Auto-create reminder unless skip_reminder=true or no reminderRepo
+            if (!input.skip_reminder && reminderRepo) {
+                try {
+                    await reminderRepo.create({
+                        user_id: input.user_id,
+                        content: `日程提醒：${input.title} ${input.start_time}`,
+                        remind_at: subtractMinutes(input.start_time, 15),
+                        channel: input.channel,
+                        timeblock_id: block.id,
+                    });
+                }
+                catch {
+                    // §4.5 静默折叠：reminder 是附加功能，建失败不应阻断日程创建。
+                    // 吞掉的错误类型：推送服务不可用 / reminder repo 写入异常。
+                    // createSchedule 主链路（日程已入库）不受影响，调用方可从 reminder 表查缺失记录。
+                    console.warn("[createSchedule] 自动建提醒失败，日程已正常创建");
+                }
+            }
+            // S32: reply_contract — 声明这轮回复该有的结构 slot
+            const reply_contract = await shouldAskDecompose(input, categoryRepo)
+                ? { required_slots: ["ask_decompose"], slot_schema: { ask_decompose: ASK_DECOMPOSE_SLOT } }
+                : { required_slots: [] };
+            // MV-COACH-3 Slice 4 v2 + 2026-07-29 重构：
+            // 主 session 一次性建全 2 个独立 cron（开工 + 追问），每个单职责、互不依赖。
+            // ⚠️ 不再让开工 cron 现场建追问 cron——cron-session 是受限环境（无 terminal/code 审批），
+            // 现场建子 cron 会卡死，连主提醒都被吞掉（2026-07-29 教训）。
+            // ⚠️ 2026-07-29 第二个教训：cron-session 也没有平台用户上下文，LLM 会乱猜 user_id
+            // （实测查了 amos 而非真正的 libero），所以 user_id 必须由主 session 焊进 cron prompt。
+            const title = input.title;
+            const startTime = input.start_time;
+            const userId = input.user_id;
+            const durationMin = input.duration_minutes;
+            const followUpOffsetMin = durationMin ? Math.floor(durationMin / 2) : 30;
+            // Bug 2（2026-07-31）：一次性日程默认 is_recurring=false → cron 焊 repeat=1
+            // 实测教训：cron 名字叫「今天 14:00」但 Repeat: ∞，第二天还在响。
+            const isRecurring = input.is_recurring === true;
+            const repeatClause = isRecurring ? "" : " repeat=1";
+            const repeatNote = isRecurring
+                ? ""
+                : `\n          ⚠️ Bug 2 教训（2026-07-31）：这是一次性日程（用户说"今天/今晚/明天/后天"），cron 必须加 repeat=1——不加会变成每日循环，日程已过期还在响。`;
+            const next_action_required = {
+                current_step: 1,
+                must_do_next: `立刻调 2 次 cronjob(action=create, deliver=origin)，分别建【开工 cron】和【追问 cron】——主 session 一次建全，不靠 cron 现场建子 cron（2026-07-29 教训：cron-session 受限环境建子 cron 会卡死，连主提醒都吞掉）。\n` +
+                    `① 开工 cron：schedule = 日程开始时间提前 15min，格式 "分 时 * * *"（如 10:30 开始 → "15 10 * * *"）。短日程例外：日程本身就是 +5min 这种短时，直接用用户给的时间，不提前。${isRecurring ? "" : "一次性日程必须传 repeat=1（Bug 2）。"}\n` +
+                    `② 追问 cron：schedule = 日程开始时间 + ${followUpOffsetMin}min（如 10:30 开始 + ${followUpOffsetMin}min），同样格式 "分 时 * * *"。${isRecurring ? "" : "一次性日程同样必须传 repeat=1。"}\n` +
+                    `⚠️ 两条 cron 的 prompt 里所有 timeblock.list/update 调用都必须带上 user_id: "${userId}"——cron-session 没有平台用户上下文，不焊 user_id 会查错用户（2026-07-29 实测：LLM 乱猜成 amos 导致状态机失效）。\n` +
+                    `📋 完整调用示例：cronjob(action="create", name="...", schedule="15 10 * * *", prompt="...", deliver="origin"${repeatClause})`,
+                cron_prompt_template: `【开工 cron prompt 模板】（schedule=日程开始时间-15min，${isRecurring ? "循环" : "一次性 → 必须 repeat=1"}）\n` +
+                    `cronjob(\n` +
+                    `  action="create",\n` +
+                    `  name="${title} 提前提醒",\n` +
+                    `  schedule="<开工时间-15min 的 '分 时 * * *'>",\n` +
+                    `  prompt="[Libero 教练闭环 - 提前提醒] 距离用户约定的 ${title} 开工时间还有 15 分钟。\\n执行 2 步：\\n1. 推送提前提醒（不超过 2 行）：🔔 15 分钟后是你约定的 ${title}（${startTime} 开始）。准备好就开始，要开始了跟我说一声。\\n   ⚠️ 不要问'要不要帮你开番茄钟'，不要调 timer.startFocus——计时是用户主动发起的动作。\\n2. 调 timeblock.list({user_id:'${userId}', status:'planned'}) 找到 start_time 是 ${startTime} 的这条 schedule，拿 id，再调 timeblock.update(id=..., status:'unverified')。\\n   ⚠️ user_id 必须用 '${userId}'——你（cron-session）没有用户上下文，乱猜会查错。\\n⚠️ 不要建任何新 cron——追问 cron 已由主 session 建好，你只需推提醒 + 标状态。",\n` +
+                    `  deliver="origin"${repeatClause}\n` +
+                    `)${repeatNote}\n\n` +
+                    `【追问 cron prompt 模板】（schedule=日程开始时间+${followUpOffsetMin}min，${isRecurring ? "循环" : "一次性 → 必须 repeat=1"}）\n` +
+                    `cronjob(\n` +
+                    `  action="create",\n` +
+                    `  name="${title} 追问",\n` +
+                    `  schedule="<追问时间的 '分 时 * * *'>",\n` +
+                    `  prompt="[Libero 教练闭环 - 追问] 用户 ${startTime} 的 ${title} 到现在没确认执行。\\n执行 2 步：\\n1. 温和追问一次（不带评判）：看到 ${startTime} 那段好像还没动——是忘了、卡住、还是计划需要调整？\\n2. 调 timeblock.list({user_id:'${userId}', status:'unverified'}) 找到 start_time 是 ${startTime} 这条，查用户回应：答执行了→timeblock.update(status:'completed')+回'👍 记下了。要不要起个番茄钟？'（⚠️ Bug 3：只升 status，禁止自动调 timer.startFocus，"开始了"是确认执行不是请求开计时）；答没执行→timeblock.remove(id)软删+回'了解，已撤掉这条'；不答→保持 unverified，什么都不做。\\n   ⚠️ user_id 必须用 '${userId}'。\\n   ⚠️ Bug 1 教训（2026-07-31）：如果 timeblock.list 找不到 start_time 是 ${startTime} 的 unverified 记录（说明用户已确认执行升 completed，或已软删）→ **静默退出，绝对不要 timeblock.update 任何东西**。后端代码层也已加守卫拒绝 completed→unverified，但你仍应避免发起这种调用。\\n⚠️ 这是唯一一次追问，无论用户回不回，不再追加，也不再建任何新 cron。",\n` +
+                    `  deliver="origin"${repeatClause}\n` +
+                    `)${repeatNote}`,
+                reminder_note: "⚠️ 提醒 ≠ 计时。开工 cron 只推提醒（'时间快到了'），绝对不帮用户开番茄钟。" +
+                    "用户主动说'开始了'才调 timer.startFocus。收到提醒 ≠ 用户开始执行。",
+                should_ask_review: true,
+            };
+            return { ...block, reply_contract, next_action_required };
+        },
+        async listSchedules(filters) {
+            return repo.list({
+                user_id: filters.user_id,
+                status: "planned",
+                from: filters.from,
+                to: filters.to,
+            });
+        },
+        async checkConflict(input) {
+            return repo.findOverlapping({
+                user_id: input.user_id,
+                start: input.start_time,
+                end: input.end_time,
+            });
+        },
+        /**
+         * MV-COACH-5 §4.1 setIntent——注册意图（提醒/追问/复盘等）。
+         * 脑层（skill）调这个，不直接调宿主的 cronjob。
+         * 通用核心记意图到 reminders 表（升格为意图队列），调 activeAdapter 翻译成宿主机制。
+         *
+         * §4.5 静默折叠声明：
+         * - activeAdapter=null（无宿主推送能力）→ 写 DB status=pending，不抛错（降级路径）
+         * - adapter.publish 失败 → status=failed，不静默（错误显式上报）
+         */
+        async setIntent(input) {
+            if (!reminderRepo) {
+                throw new Error("scheduler.setIntent 需要 reminderRepo（未注入）");
+            }
+            if (!intentDb) {
+                throw new Error("scheduler.setIntent 需要 intentDb（raw DB 句柄，用于写 intent_* 列）");
+            }
+            if (!input.action_prompt || input.action_prompt.trim() === "") {
+                throw new Error("action_prompt 不能为空");
+            }
+            if ((input.intent_type === "pre_start_reminder" ||
+                input.intent_type === "missed_check") &&
+                !input.schedule_id) {
+                throw new Error(`${input.intent_type} 需要 schedule_id（关联的 timeblock）`);
+            }
+            const nowIso = new Date().toISOString();
+            const intentId = `intent_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+            const triggerPayload = JSON.stringify(input.trigger);
+            const triggerKind = input.trigger.kind;
+            // remind_at 必须语义真实：微信推送循环按它到点触发（2026-09-02 修复：不再占位"现在"）
+            const remindAt = computeRemindAt(input.trigger, input.schedule_id, undefined, nowIso);
+            // 直接 INSERT 整行（绕过 reminderRepo.create 的 remind_at ISO 校验 + 不认 intent_* 字段）
+            intentDb
+                .prepare(`INSERT INTO reminders
+            (id, user_id, timeblock_id, content, remind_at, channel, status, attempts, created_at, updated_at,
+             intent_type, trigger_kind, trigger_payload)
+           VALUES (?, ?, ?, ?, ?, '', 'pending', 0, ?, ?,
+             ?, ?, ?)`)
+                .run(intentId, input.user_id, input.schedule_id ?? null, input.action_prompt, remindAt, nowIso, nowIso, input.intent_type, triggerKind, triggerPayload);
+            const db = intentDb;
+            // 调 activeAdapter
+            if (!activeAdapter) {
+                return { intent_id: intentId, dispatched_via: "pending" };
+            }
+            try {
+                const intent = {
+                    id: intentId,
+                    user_id: input.user_id,
+                    intent_type: input.intent_type,
+                    schedule_id: input.schedule_id,
+                    trigger: input.trigger,
+                    action_prompt: input.action_prompt,
+                    status: "pending",
+                    created_at: nowIso,
+                    updated_at: nowIso,
+                };
+                const { host_job_id } = await activeAdapter.publish(intent);
+                db.prepare(`UPDATE reminders SET status='dispatched', host_job_id=?, host_kind=?, updated_at=? WHERE id=?`).run(host_job_id, activeAdapter.kind, new Date().toISOString(), intentId);
+                return {
+                    intent_id: intentId,
+                    dispatched_via: activeAdapter.kind,
+                    host_job_id,
+                };
+            }
+            catch (e) {
+                db.prepare(`UPDATE reminders SET status='failed', host_kind=?, updated_at=? WHERE id=?`).run(activeAdapter.kind, new Date().toISOString(), intentId);
+                throw new Error(`adapter.publish 失败（intent ${intentId} 标 failed）：${e.message}`);
+            }
+        },
+        /**
+         * MV-COACH-5 §4.2 cancelIntent——撤销意图。
+         * 用户删日程时连带撤提醒/追问。
+         */
+        async cancelIntent(input) {
+            if (!intentDb) {
+                throw new Error("scheduler.cancelIntent 需要 intentDb");
+            }
+            const row = intentDb
+                .prepare("SELECT host_job_id, status FROM reminders WHERE id=?")
+                .get(input.intent_id);
+            if (!row) {
+                throw new Error(`intent ${input.intent_id} 不存在`);
+            }
+            // 调 adapter.cancel（有 host_job_id 才调）
+            if (row.host_job_id && activeAdapter) {
+                try {
+                    await activeAdapter.cancel(row.host_job_id);
+                }
+                catch (e) {
+                    console.warn(`[cancelIntent] adapter.cancel 失败（继续标本地 cancelled）：${e.message}`);
+                }
+            }
+            intentDb
+                .prepare(`UPDATE reminders SET status='cancelled', updated_at=? WHERE id=?`)
+                .run(new Date().toISOString(), input.intent_id);
+            return { cancelled: true };
+        },
+    };
+}
+/**
+ * 从 trigger 算 remind_at。
+ * 2026-09-02 生产事故修复：占位写"现在"导致微信推送循环（INT-weixin reminder-loop）
+ * 建账即推送——absolute/relative 必须落到真实触发时刻（归一化 Z）；
+ * recurring 归 adapter（cron），remind_at 保持近似并由推送循环按 trigger_kind 跳过。
+ * reminders 表 remind_at NOT NULL。
+ */
+function parseOffsetMs(offset) {
+    const m = /^(\d+)\s*([mhd])$/i.exec(offset.trim());
+    if (!m)
+        return 0;
+    const n = Number(m[1]);
+    return n * (m[2].toLowerCase() === "m" ? 60_000 : m[2].toLowerCase() === "h" ? 3_600_000 : 86_400_000);
+}
+function computeRemindAt(trigger, scheduleId, _repo, nowIso) {
+    if (trigger.kind === "absolute") {
+        const t = Date.parse(trigger.at);
+        return Number.isFinite(t) ? new Date(t).toISOString() : nowIso;
+    }
+    if (trigger.kind === "relative") {
+        const offset = parseOffsetMs(trigger.offset ?? "");
+        return new Date(Date.parse(nowIso) + (offset > 0 ? offset : 0)).toISOString();
+    }
+    // recurring：真正触发靠 adapter cron
+    return nowIso;
+}

package/dist/mcp/src/stats/index.js

@@ -0,0 +1,29 @@
+import { effectiveUserId } from "../profile-helpers.js";
+export function createStatsTools(repo) {
+    return {
+        async summarize(filters) {
+            if (!filters.user_id) {
+                throw new Error("user_id 为必填参数");
+            }
+            if (filters.from !== undefined &&
+                filters.to !== undefined &&
+                filters.from > filters.to) {
+                throw new Error("开始时间不能晚于结束时间");
+            }
+            const userId = effectiveUserId(filters);
+            return repo.summarize({ ...filters, user_id: userId });
+        },
+        async dailyBreakdown(filters) {
+            if (!filters.user_id) {
+                throw new Error("user_id 为必填参数");
+            }
+            if (filters.from !== undefined &&
+                filters.to !== undefined &&
+                filters.from > filters.to) {
+                throw new Error("开始时间不能晚于结束时间");
+            }
+            const userId = effectiveUserId(filters);
+            return repo.dailyBreakdown({ ...filters, user_id: userId });
+        },
+    };
+}