libero-mcp 0.2.21 → 0.2.22

package/data/migrations/015_timeblock_asked_at.sql

@@ -0,0 +1,5 @@
+-- S48 (2026-08-11): time_blocks 加 asked_at 字段
+-- 用于 libero-cron-scan 幂等：每条 unverified/planned 只被扫描追问一次
+-- 写入时机：sweepStale 把条目放进 to_ask 结果前/后，由扫描 caller 标记（或 sweepStale 内部标记）
+-- 复位规则：用户回报（completed / 软删）后这条不再被扫；asked_at 永久保留作审计
+ALTER TABLE time_blocks ADD COLUMN asked_at TEXT;

package/data/schema.sql

@@ -26,6 +26,8 @@ CREATE TABLE IF NOT EXISTS time_blocks (
   created_at TEXT NOT NULL DEFAULT (datetime('now')),
   updated_at TEXT NOT NULL DEFAULT (datetime('now')),
   deleted_at TEXT,
+  -- status/rating/rating_reason 由后续 migration 加；此处不显式列（IF NOT EXISTS 不重建表）
+  -- asked_at（migration 015，S48）：扫描追问幂等标记，每条只主动问一次
   FOREIGN KEY (user_id) REFERENCES user_profile(id)
 );
 

package/dist/data/migrations/015_timeblock_asked_at.sql

@@ -0,0 +1,5 @@
+-- S48 (2026-08-11): time_blocks 加 asked_at 字段
+-- 用于 libero-cron-scan 幂等：每条 unverified/planned 只被扫描追问一次
+-- 写入时机：sweepStale 把条目放进 to_ask 结果前/后，由扫描 caller 标记（或 sweepStale 内部标记）
+-- 复位规则：用户回报（completed / 软删）后这条不再被扫；asked_at 永久保留作审计
+ALTER TABLE time_blocks ADD COLUMN asked_at TEXT;

package/dist/data/schema.sql

@@ -26,6 +26,8 @@ CREATE TABLE IF NOT EXISTS time_blocks (
   created_at TEXT NOT NULL DEFAULT (datetime('now')),
   updated_at TEXT NOT NULL DEFAULT (datetime('now')),
   deleted_at TEXT,
+  -- status/rating/rating_reason 由后续 migration 加；此处不显式列（IF NOT EXISTS 不重建表）
+  -- asked_at（migration 015，S48）：扫描追问幂等标记，每条只主动问一次
   FOREIGN KEY (user_id) REFERENCES user_profile(id)
 );
 

package/dist/knowledge/src/repo/fs-yaml.js

@@ -0,0 +1,252 @@
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import yaml from "js-yaml";
+import { validateEntry } from "../../_schema/entry.schema.js";
+import { validateAnalysisModel } from "../../_schema/analysis-model.schema.js";
+import { validateScenarioPack } from "../../_schema/scenario-pack.schema.js";
+import { validatePersonaRegistry } from "../../_schema/persona.schema.js";
+/** Repository root dir (two levels up from knowledge/src/repo/ → knowledge/) */
+function defaultBasePath() {
+    // When running via tsx, import.meta.dirname is the dir of this file
+    return join(import.meta.dirname, "..", "..");
+}
+export class FsYamlKnowledgeRepo {
+    basePath;
+    _all = null;
+    _dimensions = null;
+    _analysisModels = null;
+    _scenarioPacks = null;
+    _personas = null;
+    constructor(basePath) {
+        this.basePath = basePath ?? defaultBasePath();
+    }
+    /** Load the dimensions registry from _registry/dimensions.yaml */
+    loadDimensions() {
+        if (this._dimensions)
+            return this._dimensions;
+        const path = join(this.basePath, "_registry", "dimensions.yaml");
+        if (!existsSync(path)) {
+            throw new Error(`维度注册表不存在: ${path}`);
+        }
+        const raw = yaml.load(readFileSync(path, "utf-8"));
+        if (!raw || !Array.isArray(raw.dimensions)) {
+            throw new Error(`维度注册表格式错误: ${path}`);
+        }
+        const dims = raw.dimensions.map((d) => d.id);
+        this._dimensions = dims;
+        return dims;
+    }
+    /** Collect all .yaml file paths under basePath, excluding _schema/, _registry/ and tests/ */
+    collectYamlFiles(dir, root) {
+        const files = [];
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Skip non-content directories.
+                // analysis-models/ 与 scenario-packs/ 是 COACH-MOD 新增内容类型，
+                // 用独立 schema（非 knowledgeEntrySchema），不能被 loadAll 当处方条目校验，
+                // 否则 validate 报错 / T13 迁移等价性断言崩。它们由 loadAnalysisModels
+                // / loadScenarioPacks 单独加载。
+                if (entry.name === "_schema" ||
+                    entry.name === "_registry" ||
+                    entry.name === "tests" ||
+                    entry.name === "analysis-models" ||
+                    entry.name === "scenario-packs")
+                    continue;
+                files.push(...this.collectYamlFiles(fullPath, root));
+            }
+            else if (entry.isFile() && entry.name.endsWith(".yaml")) {
+                files.push(fullPath);
+            }
+        }
+        return files;
+    }
+    async loadAll() {
+        if (this._all)
+            return this._all;
+        // Load registry first
+        const validDimensions = this.loadDimensions();
+        const yamlFiles = this.collectYamlFiles(this.basePath, this.basePath);
+        const entries = [];
+        const seenIds = new Set();
+        for (const filePath of yamlFiles) {
+            const raw = yaml.load(readFileSync(filePath, "utf-8"));
+            const entry = validateEntry(raw);
+            // Check dimension is registered
+            if (!validDimensions.includes(entry.dimension)) {
+                throw new Error(`维度 "${entry.dimension}" 未在 _registry/dimensions.yaml 中登记 ` +
+                    `(文件: ${filePath})`);
+            }
+            // Check duplicate ID
+            if (seenIds.has(entry.id)) {
+                throw new Error(`重复 ID: "${entry.id}" (文件: ${filePath})`);
+            }
+            seenIds.add(entry.id);
+            entries.push(entry);
+        }
+        this._all = entries;
+        return entries;
+    }
+    async getById(id) {
+        const entries = await this.loadAll();
+        return entries.find((e) => e.id === id) ?? null;
+    }
+    async byDimension(dimension) {
+        const entries = await this.loadAll();
+        return entries.filter((e) => e.dimension === dimension);
+    }
+    async matchBySignal(signal) {
+        const entries = await this.loadAll();
+        return entries.filter((e) => {
+            const signals = e.triggers.signals ?? [];
+            return signals.some((s) => {
+                // Quadrant match: exact
+                if (signal.quadrant && s.quadrant) {
+                    if (s.quadrant !== signal.quadrant)
+                        return false;
+                }
+                else if (signal.quadrant && !s.quadrant) {
+                    return false;
+                }
+                // Daily total minutes: parse threshold
+                if (signal.daily_total_minutes && s.daily_total_minutes) {
+                    const sv = parseThreshold(s.daily_total_minutes);
+                    const qv = parseThreshold(signal.daily_total_minutes);
+                    if (sv === null || qv === null) {
+                        // If we can't parse, fall back to string equality
+                        if (s.daily_total_minutes !== signal.daily_total_minutes)
+                            return false;
+                    }
+                    else if (!matchesThreshold(s.daily_total_minutes, signal.daily_total_minutes)) {
+                        return false;
+                    }
+                }
+                else if (signal.daily_total_minutes && !s.daily_total_minutes) {
+                    return false;
+                }
+                // If neither signal field is being queried, no match
+                if (!signal.quadrant && !signal.daily_total_minutes)
+                    return false;
+                return true;
+            });
+        });
+    }
+    async matchBySymptom(symptom) {
+        const entries = await this.loadAll();
+        const lowerSymptom = symptom.toLowerCase();
+        return entries.filter((e) => {
+            const symptoms = e.triggers.symptoms ?? [];
+            return symptoms.some((s) => s.toLowerCase().includes(lowerSymptom));
+        });
+    }
+    /** Collect .yaml files directly under one content subdir (non-recursive). */
+    collectDirYamlFiles(subdir) {
+        const dir = join(this.basePath, subdir);
+        if (!existsSync(dir))
+            return [];
+        return readdirSync(dir, { withFileTypes: true })
+            .filter((e) => e.isFile() && e.name.endsWith(".yaml"))
+            .map((e) => join(dir, e.name));
+    }
+    /** COACH-MOD: load all analysis models from analysis-models/. */
+    async loadAnalysisModels() {
+        if (this._analysisModels)
+            return this._analysisModels;
+        const files = this.collectDirYamlFiles("analysis-models");
+        const models = [];
+        const seenIds = new Set();
+        for (const filePath of files) {
+            const raw = yaml.load(readFileSync(filePath, "utf-8"));
+            const model = validateAnalysisModel(raw);
+            if (seenIds.has(model.id)) {
+                throw new Error(`重复分析模型 ID: "${model.id}" (文件: ${filePath})`);
+            }
+            seenIds.add(model.id);
+            models.push(model);
+        }
+        this._analysisModels = models;
+        return models;
+    }
+    /** COACH-MOD: load all scenario packs from scenario-packs/. */
+    async loadScenarioPacks() {
+        if (this._scenarioPacks)
+            return this._scenarioPacks;
+        const files = this.collectDirYamlFiles("scenario-packs");
+        const packs = [];
+        const seenIds = new Set();
+        for (const filePath of files) {
+            const raw = yaml.load(readFileSync(filePath, "utf-8"));
+            const pack = validateScenarioPack(raw);
+            if (seenIds.has(pack.id)) {
+                throw new Error(`重复场景包 ID: "${pack.id}" (文件: ${filePath})`);
+            }
+            seenIds.add(pack.id);
+            packs.push(pack);
+        }
+        this._scenarioPacks = packs;
+        return packs;
+    }
+    /** COACH-MOD: load personas from _registry/personas.yaml. */
+    async loadPersonas() {
+        if (this._personas)
+            return this._personas;
+        const path = join(this.basePath, "_registry", "personas.yaml");
+        if (!existsSync(path)) {
+            this._personas = [];
+            return [];
+        }
+        const raw = yaml.load(readFileSync(path, "utf-8"));
+        const { personas } = validatePersonaRegistry(raw ?? {});
+        const seenIds = new Set();
+        for (const p of personas) {
+            if (seenIds.has(p.id)) {
+                throw new Error(`重复画像 ID: "${p.id}" (文件: ${path})`);
+            }
+            seenIds.add(p.id);
+        }
+        this._personas = personas;
+        return personas;
+    }
+    /**
+     * COACH-MOD: return the single default analysis model (is_default: true).
+     * §4.5 显式声明：0 个或 >1 个默认都抛错（不静默返回 undefined / 第一个），
+     * 因为"复盘默认装一个基线"是硬约束（spec §2 ①原则·基线）。
+     */
+    async getDefaultAnalysisModel() {
+        const models = await this.loadAnalysisModels();
+        const defaults = models.filter((m) => m.is_default);
+        if (defaults.length === 0) {
+            throw new Error("没有默认分析模型（需要恰好一个 is_default: true）");
+        }
+        if (defaults.length > 1) {
+            throw new Error(`默认分析模型不唯一：${defaults.map((m) => m.id).join(", ")}（需要恰好一个 is_default: true）`);
+        }
+        return defaults[0];
+    }
+}
+/** Parse a threshold string like ">600" into { op: ">", value: 600 } */
+function parseThreshold(s) {
+    const match = s.match(/^([><=]?)\s*(\d+)$/);
+    if (!match)
+        return null;
+    return { op: match[1] || ">=", value: parseInt(match[2], 10) };
+}
+/** Check if the entry's daily_total_minutes matches the query threshold */
+function matchesThreshold(entryValue, queryValue) {
+    const pv = parseThreshold(queryValue);
+    if (!pv)
+        return entryValue === queryValue;
+    // For entry values that are plain numbers or threshold expressions
+    const entryMatch = entryValue.match(/^(\d+)$/);
+    if (entryMatch) {
+        const num = parseInt(entryMatch[1], 10);
+        switch (pv.op) {
+            case ">": return num > pv.value;
+            case "<": return num < pv.value;
+            case "=": return num === pv.value;
+            default: return num >= pv.value;
+        }
+    }
+    return entryValue === queryValue;
+}

package/dist/mcp/server-core.js

@@ -12,6 +12,8 @@ import { createProfileConfirmTools } from "./src/profile/confirm-default.js";
 import { createReminderTools } from "./src/reminder/index.js";
 import { createSchedulerTools } from "./src/scheduler/index.js";
 import { createTaskTools } from "./src/task/index.js";
+import { createCoachModTools } from "./src/coachmod/index.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";
@@ -51,7 +53,7 @@ export function errorContent(msg) {
  * preserving declaration order for diagnostic readability.
  */
 function buildToolRegistry(ctx) {
-    const { categories, tb, stats, matrix, timeline, timer, profile, profileConfirm, reminder, scheduler, task, injector, } = ctx;
+    const { categories, tb, stats, matrix, timeline, timer, profile, profileConfirm, reminder, scheduler, task, coachmod, injector, } = ctx;
     // identityRepo is referenced directly inside handlers below (closure scope),
     // matching the pre-refactor behavior.
     const identityRepo = ctx.repos.identityRepo;
@@ -305,8 +307,8 @@ function buildToolRegistry(ctx) {
         name: "timeblock.sweepStale",
         description: "S43 过期扫描：列出某用户当天过期未确认的 timeblock，分两组返回。" +
             "to_unverified：end_time 已过 30min 仍 planned（该升级 unverified）。" +
-            "to_ask：end_time 已过 60min 仍 unverified/planned（该主动问用户）。" +
-            "⚠️ 纯查询，不改 db——caller（cron-session LLM）需对 to_unverified 显式调 timeblock.update(status=unverified)，对 to_ask 调 cronjob create 发追问。" +
+            "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),
@@ -329,6 +331,69 @@ function buildToolRegistry(ctx) {
             }
         },
     });
+    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)
     // ============================================================
@@ -984,6 +1049,9 @@ export function buildServer(db) {
     const reminder = createReminderTools(repos.reminderRepo, undefined, db);
     const scheduler = createSchedulerTools(repos.timeblockRepo, repos.reminderRepo, repos.categoryRepo);
     const task = createTaskTools(db);
+    // ── COACH-MOD slice 1: knowledge repo + coachmod tools ──
+    const knowledgeRepo = new FsYamlKnowledgeRepo();
+    const coachmod = createCoachModTools(knowledgeRepo, db);
     // instructions 必须放在第 2 参 ServerOptions（不是 serverInfo）—— SDK 只从 options 读
     const server = new McpServer({ name: "libero-mcp", version: "0.2.3" }, { instructions: buildServerInstructions() });
     // ── MC-0a: build registry once, register in a single traversal ──
@@ -1000,6 +1068,7 @@ export function buildServer(db) {
         reminder,
         scheduler,
         task,
+        coachmod,
         injector,
         db,
     };

package/dist/mcp/src/repo/in-memory.js

@@ -139,6 +139,21 @@ export class InMemoryTimeBlockRepo {
     async userExists(userId) {
         return this.userIds.has(userId);
     }
+    /** S48（2026-08-11）：标记扫描追问已发。幂等保护。 */
+    async markAsked(ids, askedAt) {
+        if (!ids || ids.length === 0)
+            return 0;
+        const ts = askedAt ?? new Date().toISOString();
+        let changed = 0;
+        for (const b of this.blocks) {
+            if (ids.includes(b.id) && !b.deleted_at) {
+                b.asked_at = ts;
+                b.updated_at = ts;
+                changed++;
+            }
+        }
+        return changed;
+    }
     async findOverlapping(input) {
         return this.blocks
             .filter((b) => b.user_id === input.user_id &&

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

@@ -147,6 +147,18 @@ export class SqliteTimeBlockRepo {
             .get(userId);
         return !!row;
     }
+    /** S48（2026-08-11）：标记扫描追问已发。幂等保护：每条只被 cron 主动问一次。返回受影响行数。 */
+    async markAsked(ids, askedAt) {
+        if (!ids || ids.length === 0)
+            return 0;
+        const ts = askedAt ?? new Date().toISOString();
+        const placeholders = ids.map(() => "?").join(", ");
+        const result = this.db
+            .prepare(`UPDATE time_blocks SET asked_at = ?, updated_at = ?
+         WHERE id IN (${placeholders}) AND deleted_at IS NULL`)
+            .run(ts, ts, ...ids);
+        return result.changes;
+    }
     async restore(id) {
         const row = this.db
             .prepare("SELECT id, deleted_at FROM time_blocks WHERE id = ?")

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

@@ -118,17 +118,17 @@ export function createTimeBlockTools(repo, db) {
             return repo.restore(id);
         },
         /**
-         * S43（2026-08-07）：扫描某用户过期未确认的 timeblock，分组返回。
+         * S43（2026-08-07）+ S48（2026-08-11）：扫描某用户过期未确认的 timeblock，分组返回。
          *
          * 用途：cron-session 每 30min 调一次，让 cron LLM 显式调 timeblock.update
          * 升级状态 + 主动问。本工具**不**直接改 db（保留 brain/hand 分离 + 用户主权模型）。
          *
          * 判定逻辑（以 now 为基准）：
          * - end_time + overdue_min_to_unverified (默认 30min) 仍 planned → to_unverified
-         * - end_time + overdue_min_to_ask (默认 60min) 仍 unverified/planned → to_ask
-         * - completed / 未过期 / 软删的 → 都不进
+         * - end_time + overdue_min_to_ask (默认 60min) 仍 unverified/planned，**且 asked_at IS NULL**（S48：每条只问一次）→ to_ask
+         * - completed / 未过期 / 软删 / asked_at 已标记的 → 都不进 to_ask
          *
-         * §4.5 静默折叠声明：纯查询，无副作用，无折叠。
+         * §4.5 静默折叠声明：纯查询，无副作用，无折叠。caller 发完追问后必须调 markAsked 幂等标记。
          */
         async sweepStale(input) {
             if (!input.user_id) {
@@ -167,7 +167,8 @@ export function createTimeBlockTools(repo, db) {
                         end_time: b.end_time,
                     });
                 }
-                if (overdueAsk && (b.status === "unverified" || b.status === "planned")) {
+                // S48 幂等：asked_at 已标记的不再进 to_ask（每条只被扫描 cron 主动问一次）
+                if (overdueAsk && (b.status === "unverified" || b.status === "planned") && !b.asked_at) {
                     to_ask.push({
                         id: b.id,
                         title: b.title,
@@ -179,5 +180,16 @@ export function createTimeBlockTools(repo, db) {
             }
             return { to_unverified, to_ask, now: nowIso };
         },
+        /**
+         * S48（2026-08-11）：标记扫描追问已发——幂等保护。
+         * caller（cron-scan skill）发完追问后必须调用，写入 asked_at 时间戳。
+         * 返回受影响行数（用于 caller 自检）。无副作用之外的折叠（asked_at 永久保留作审计）。
+         */
+        async markAsked(ids) {
+            if (!ids || ids.length === 0)
+                return { marked: 0 };
+            const marked = await repo.markAsked(ids);
+            return { marked };
+        },
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libero-mcp",
-  "version": "0.2.21",
+  "version": "0.2.22",
   "description": "AI 时间管理教练 MCP 工具集——时间块记录、统计、矩阵诊断、计时、分类、profile",
   "license": "MIT",
   "author": "amosyuan",