libero3 0.3.0

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

@@ -0,0 +1,135 @@
+/** Read profile settings.focus_areas as extra matching tokens (deterministic). */
+function readProfileTokens(db, userId) {
+    const row = db
+        .prepare(`SELECT settings FROM user_profile WHERE id = ? AND deleted_at IS NULL`)
+        .get(userId);
+    if (!row?.settings)
+        return [];
+    try {
+        const parsed = JSON.parse(row.settings);
+        if (Array.isArray(parsed.focus_areas)) {
+            return parsed.focus_areas.filter((x) => typeof x === "string");
+        }
+    }
+    catch {
+        // §4.5：settings 非法 JSON 不阻断 suggest（画像线索只是加分项，非必需）——
+        // 明确声明此折叠：坏 settings 退化为"无 profile 线索"，仍返回默认模型 + 空候选。
+        return [];
+    }
+    return [];
+}
+export function createCoachModTools(knowledgeRepo, db) {
+    return {
+        /** §4.1 确定性粗筛候选 + 始终附默认基线模型。 */
+        async suggest(input) {
+            const defaultModel = await knowledgeRepo.getDefaultAnalysisModel();
+            const packs = await knowledgeRepo.loadScenarioPacks();
+            // 构造匹配 haystack：context_hint + profile focus_areas
+            const tokens = [];
+            if (input.context_hint)
+                tokens.push(input.context_hint);
+            if (input.user_id)
+                tokens.push(...readProfileTokens(db, input.user_id));
+            const haystack = tokens.join(" ");
+            const candidates = [];
+            for (const pack of packs) {
+                const matched = pack.triggers.context_tags.filter((tag) => haystack.includes(tag));
+                if (matched.length > 0) {
+                    candidates.push({
+                        type: "scenario-pack",
+                        id: pack.id,
+                        title: pack.title,
+                        why_matched: `命中标签[${matched.join(",")}]`,
+                    });
+                }
+            }
+            const result = {
+                default_model: { id: defaultModel.id, title: defaultModel.title },
+                candidates,
+            };
+            if (candidates.length === 0) {
+                result.note = "无场景包命中，用默认模型";
+            }
+            return result;
+        },
+        /** §4.2 渐进披露：只返回请求的 ids；场景包展开 recommends；坏 id 抛错。 */
+        async load(input) {
+            if (!input.ids || input.ids.length === 0) {
+                throw new Error("ids 不能为空");
+            }
+            const [models, packs, personas] = await Promise.all([
+                knowledgeRepo.loadAnalysisModels(),
+                knowledgeRepo.loadScenarioPacks(),
+                knowledgeRepo.loadPersonas(),
+            ]);
+            const modelMap = new Map(models.map((m) => [m.id, m]));
+            const packMap = new Map(packs.map((p) => [p.id, p]));
+            const personaMap = new Map(personas.map((p) => [p.id, p]));
+            const toLoadedModel = (m) => ({
+                id: m.id,
+                title: m.title,
+                description: m.description,
+                method: m.method,
+                output_shape: m.output_shape,
+            });
+            const toLoadedPersona = (p) => ({
+                id: p.id,
+                label: p.label,
+                traits: p.traits,
+                constraints: p.constraints,
+                tone_adjust: p.tone_adjust,
+            });
+            const loaded = [];
+            for (const id of input.ids) {
+                const pack = packMap.get(id);
+                if (pack) {
+                    const persona = personaMap.get(pack.recommends.persona_id);
+                    if (!persona) {
+                        throw new Error(`场景包 "${id}" 引用的画像 "${pack.recommends.persona_id}" 不存在`);
+                    }
+                    const packModels = pack.recommends.analysis_model_ids.map((mid) => {
+                        const m = modelMap.get(mid);
+                        if (!m) {
+                            throw new Error(`场景包 "${id}" 引用的分析模型 "${mid}" 不存在`);
+                        }
+                        return toLoadedModel(m);
+                    });
+                    loaded.push({
+                        id: pack.id,
+                        kind: "scenario-pack",
+                        title: pack.title,
+                        content: {
+                            subskill_prompt: pack.recommends.subskill_prompt,
+                            persona: toLoadedPersona(persona),
+                            analysis_models: packModels,
+                        },
+                    });
+                    continue;
+                }
+                const model = modelMap.get(id);
+                if (model) {
+                    loaded.push({
+                        id: model.id,
+                        kind: "analysis-model",
+                        title: model.title,
+                        content: toLoadedModel(model),
+                    });
+                    continue;
+                }
+                const persona = personaMap.get(id);
+                if (persona) {
+                    loaded.push({
+                        id: persona.id,
+                        kind: "persona",
+                        title: persona.label,
+                        content: toLoadedPersona(persona),
+                    });
+                    continue;
+                }
+                // §4.5：不存在的 id 报错，不静默返回空
+                throw new Error(`未找到 id "${id}"（不是场景包 / 分析模型 / 画像）`);
+            }
+            return { loaded };
+        },
+    };
+}

package/dist/mcp/src/host-adapters/hermes-cron.js

@@ -0,0 +1,185 @@
+/**
+ * MV-COACH-5 §5.2/§5.4 — HermesCronAdapter（hermes 平台适配层）。
+ *
+ * spike 结论（2026-08-12）：libero MCP 是 hermes 的子进程，cronjob 工具是 hermes
+ * 给自己 LLM 用的，不反向暴露给子进程。adapter 必须走 spawn CLI：
+ *   - publish: `hermes cron create <schedule> <prompt> --name ... --deliver origin [--repeat 1]`
+ *   - cancel: `hermes cron remove <job_id>`
+ *
+ * 本文件先实装纯函数 translateTriggerToHermesSchedule（核心可测逻辑），
+ * publish/cancel/detect 的 spawn 部分在 slice 1 后续补（需带 mock 测试）。
+ */
+import { execFileSync } from "node:child_process";
+/**
+ * §5.4 trigger → hermes cron schedule 翻译表（纯函数）。
+ *
+ * | trigger | hermes cron schedule |
+ * |---|---|
+ * | relative -15m from schedule.start | schedule.start-15min 的 cron（一次性，repeat=1）|
+ * | relative +5m from now | "+5m"（hermes 原生相对）|
+ * | relative +30m from schedule.start | schedule.start+offset 的 cron |
+ * | absolute at=ISO | 锁日期的 cron（一次性）|
+ * | recurring cron_expr | 直接用 |
+ *
+ * §4.5 静默折叠声明：
+ * - relative_to=schedule.start 但缺 scheduleStartIso → 抛错（不静默返回空）
+ * - offset 格式非法 → 抛错
+ * - absolute 过去时间（> 120s 前）→ 抛错（hermes 会拒）
+ */
+export function translateTriggerToHermesSchedule(trigger, ctx = {}) {
+    switch (trigger.kind) {
+        case "relative":
+            return translateRelative(trigger, ctx);
+        case "absolute":
+            return translateAbsolute(trigger);
+        case "recurring":
+            return { schedule: trigger.cron_expr }; // repeat=undefined = 循环
+    }
+}
+/** relative 翻译：算出触发时刻 → 转 cron。 */
+function translateRelative(trigger, ctx) {
+    const offsetMs = parseOffset(trigger.offset); // 正负均可
+    if (trigger.relative_to === "now") {
+        // hermes 原生支持 "+5m" / "+30m" 相对表达式，不用算绝对时间
+        // 注意：hermes 的相对格式是 "+5m"（带 + 号），offset 已是这个格式直接透传
+        return { schedule: trigger.offset, repeat: 1 };
+    }
+    // relative_to === "schedule.start"
+    if (!ctx.scheduleStartIso) {
+        throw new Error("relative_to=schedule.start 需要 scheduleStartIso（从 DB 查的 schedule 开始时间）");
+    }
+    const startMs = new Date(ctx.scheduleStartIso).getTime();
+    if (Number.isNaN(startMs)) {
+        throw new Error(`scheduleStartIso 格式非法: ${ctx.scheduleStartIso}`);
+    }
+    const triggerMs = startMs + offsetMs;
+    const triggerDate = new Date(triggerMs);
+    // 转本地时区的 cron（分 时 日 月 *，不填 year）
+    // 注意：相对 schedule 的具体某天 = 一次性，用 day/month 锁定日期
+    const cron = `${triggerDate.getMinutes()} ${triggerDate.getHours()} ${triggerDate.getDate()} ${triggerDate.getMonth() + 1} *`;
+    return { schedule: cron, repeat: 1 };
+}
+/** absolute 翻译：ISO → 锁日期的 cron（一次性）。 */
+function translateAbsolute(trigger) {
+    const ms = new Date(trigger.at).getTime();
+    if (Number.isNaN(ms)) {
+        throw new Error(`absolute at 格式非法: ${trigger.at}`);
+    }
+    // §4.5：hermes 拒绝 > 120s 过去的时间
+    const nowMs = Date.now();
+    if (ms < nowMs - 120 * 1000) {
+        throw new Error(`absolute at 已过去 > 120s（hermes 会拒）：${trigger.at}`);
+    }
+    const d = new Date(ms);
+    const cron = `${d.getMinutes()} ${d.getHours()} ${d.getDate()} ${d.getMonth() + 1} *`;
+    return { schedule: cron, repeat: 1 };
+}
+/**
+ * 解析 offset 字符串 → 毫秒。
+ * 格式：[+-]数字+单位（m/h），如 "-15m" / "+5m" / "+2h" / "30m"（无符号 = 正）
+ */
+export function parseOffset(offset) {
+    const m = offset.match(/^([+-]?)(\d+)([mh])$/i);
+    if (!m) {
+        throw new Error(`offset 格式非法: "${offset}"（应为 [+-]数字+m/h，如 -15m / +5m / +2h）`);
+    }
+    const sign = m[1] === "-" ? -1 : 1;
+    const n = parseInt(m[2], 10);
+    const unitMs = m[3].toLowerCase() === "h" ? 60 * 60 * 1000 : 60 * 1000;
+    return sign * n * unitMs;
+}
+/**
+ * publish 前解析相对 schedule.start 所需的 ctx（可单测，不 spawn CLI）。
+ * §4.5：缺 schedule_id / 缺 db / 行不存在 → 抛错，不静默空。
+ */
+export function resolvePublishTranslateContext(intent, db) {
+    if (intent.trigger.kind !== "relative" ||
+        intent.trigger.relative_to !== "schedule.start") {
+        return {};
+    }
+    if (!intent.schedule_id) {
+        throw new Error("relative_to=schedule.start 需要 schedule_id 才能算触发时间");
+    }
+    if (!db) {
+        throw new Error("HermesCronAdapter 未注入 db，无法查 schedule.start_time");
+    }
+    const row = db
+        .prepare("SELECT start_time FROM time_blocks WHERE id=?")
+        .get(intent.schedule_id);
+    if (!row) {
+        throw new Error(`schedule ${intent.schedule_id} 不存在`);
+    }
+    return { scheduleStartIso: row.start_time };
+}
+// ─────────────────────────────────────────────────────────────
+// HermesCronAdapter（detect + publish + cancel 的 spawn 部分）
+// ─────────────────────────────────────────────────────────────
+/**
+ * HermesCronAdapter——hermes 平台的意图适配层。
+ *
+ * detect 三探（任一命中）：
+ *   ① env LIBERO_HOST === "hermes"（显式指定，最高优先级）
+ *   ② env HERMES_HOME 存在
+ *   ③ `hermes cron list` CLI 可调用
+ *
+ * publish/cancel 走 spawn CLI（spike 结论）。
+ */
+export class HermesCronAdapter {
+    db;
+    kind = "hermes_cron";
+    /**
+     * @param db 可选——relative_to=schedule.start 时查 schedule.start_time 用。
+     * slice 1 单测不传（只测 trigger 纯函数）；server-core 实装时传生产 db。
+     */
+    constructor(db) {
+        this.db = db;
+    }
+    detect() {
+        // ① 显式指定
+        if (process.env.LIBERO_HOST === "hermes")
+            return true;
+        // ② HERMES_HOME 存在
+        if (process.env.HERMES_HOME)
+            return true;
+        // ③ CLI 可调用（保守：只在她真的能跑时才认）
+        try {
+            execFileSync("hermes", ["cron", "list"], {
+                stdio: ["ignore", "pipe", "ignore"],
+                timeout: 5000,
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async publish(intent) {
+        // relative_to=schedule.start 时查 DB 拿 start_time（slice 1 单测只覆盖纯函数，
+        // 这里是 publish 时真查 DB——tracer 暴露的必要修正）
+        const ctx = resolvePublishTranslateContext(intent, this.db);
+        const { schedule, repeat } = translateTriggerToHermesSchedule(intent.trigger, ctx);
+        const args = ["cron", "create", schedule, intent.action_prompt];
+        args.push("--name", `${intent.intent_type}:${intent.id.slice(0, 8)}`);
+        args.push("--deliver", "origin");
+        if (repeat !== undefined) {
+            args.push("--repeat", String(repeat));
+        }
+        const stdout = execFileSync("hermes", args, {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 15000,
+        });
+        // 解析 "Created job: <job_id>"
+        const m = stdout.match(/Created job:\s*([a-f0-9]+)/i);
+        if (!m) {
+            throw new Error(`hermes cron create 未返回 job_id，stdout: ${stdout}`);
+        }
+        return { host_job_id: m[1] };
+    }
+    async cancel(host_job_id) {
+        execFileSync("hermes", ["cron", "remove", host_job_id], {
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: 10000,
+        });
+    }
+}

package/dist/mcp/src/host-adapters/index.js

@@ -0,0 +1,61 @@
+/**
+ * MV-COACH-5 §5.3 — adapter 注册与选择。
+ *
+ * MCP 启动时调一次 selectAdapter()，结果缓存。
+ * 后续 setIntent / cancelIntent 用这个 active adapter。
+ *
+ * §4.5 静默折叠声明：
+ * - 所有 adapter detect() 都 false → 返回 null（降级：意图只写 DB status=pending，
+ *   等用户开口时补推，slice 4 实装）。这是产品意图（无推送平台接受降级），非缺陷。
+ */
+import { HermesCronAdapter } from "./hermes-cron.js";
+/** 所有内置 adapter（按 detect 优先级排序）。 */
+export const ADAPTERS = [
+    // 注：这里 new 的 adapter 不带 db——relative_to=schedule.start 查不了
+    // server-core 实装时用 createAdaptersWithDb(db) 拿带 db 的实例
+    new HermesCronAdapter(),
+    // slice 2 之后加：new OpenclawAdapter(),
+];
+/** server-core 实装时用这个——传入 db，adapter 才能查 schedule.start_time。 */
+export function createAdaptersWithDb(db) {
+    return [
+        new HermesCronAdapter(db),
+        // slice 2 之后加：new OpenclawAdapter(),
+    ];
+}
+/**
+ * 选当前环境能用的 adapter。
+ * 1. env LIBERO_HOST 显式指定 → 直接匹配 kind
+ * 2. 否则按顺序 detect()，第一个 true 的胜出
+ * 3. 都不命中 → null（降级）
+ */
+export function selectAdapter(adapters = ADAPTERS) {
+    // ① env 显式指定
+    const envHint = process.env.LIBERO_HOST;
+    if (envHint) {
+        const matched = adapters.find((a) => a.kind === envHint);
+        if (matched && matched.detect())
+            return matched;
+        // env 指定了但 detect 不过 → 继续走自动探测（不强行用不工作的 adapter）
+    }
+    // ② 自动探测
+    for (const adapter of adapters) {
+        if (adapter.detect())
+            return adapter;
+    }
+    // ③ 都不命中
+    return null;
+}
+/** 缓存的 active adapter（MCP 启动时调 selectAdapter 缓存结果）。 */
+let _activeAdapter;
+/** 获取（或首次解析）active adapter。 */
+export function getActiveAdapter() {
+    if (_activeAdapter === undefined) {
+        _activeAdapter = selectAdapter();
+    }
+    return _activeAdapter;
+}
+/** 测试用：重置缓存。 */
+export function _resetActiveAdapterForTest() {
+    _activeAdapter = undefined;
+}

package/dist/mcp/src/host-adapters/types.js

@@ -0,0 +1,7 @@
+/**
+ * MV-COACH-5 §5 — HostAdapter 接口（3F 架构的宿主适配层）。
+ *
+ * 脑（skill）说意图 → 手（MCP）记意图 + 调 adapter → adapter 翻译成该平台的机制。
+ * slice 1 只实装 HermesCronAdapter；后续 slice 加 OpenclawAdapter / cc_pending 降级。
+ */
+export {};

package/dist/mcp/src/identity/equivalent-ids.js

@@ -0,0 +1,41 @@
+export function equivalentUserIds(db, input) {
+    const ids = new Set([input]);
+    if (!input)
+        return [...ids];
+    const canonicalRow = db
+        .prepare(`SELECT libero_user_id AS id FROM user_platform_alias
+       WHERE platform_user_id = ? OR chat_id = ?
+       UNION
+       SELECT libero_user_id AS id FROM user_identity WHERE libero_user_id = ?
+       LIMIT 1`)
+        .get(input, input, input);
+    if (!canonicalRow)
+        return [...ids];
+    const canonical = canonicalRow.id;
+    ids.add(canonical);
+    const aliases = db
+        .prepare(`SELECT platform_user_id, chat_id FROM user_platform_alias WHERE libero_user_id = ?`)
+        .all(canonical);
+    for (const a of aliases) {
+        ids.add(a.platform_user_id);
+        if (a.chat_id)
+            ids.add(a.chat_id);
+    }
+    return [...ids];
+}
+/** 写入用：等价集里已有的 user_profile.id；没有则 null（让上层走确认/原样）。 */
+export function profileIdForWrite(db, input) {
+    const uid = userIdIn(db, "id", input);
+    const row = db
+        .prepare(`SELECT id FROM user_profile WHERE ${uid.clause} AND deleted_at IS NULL LIMIT 1`)
+        .get(...uid.params);
+    return row?.id ?? null;
+}
+/** `column IN (?,?,…)` + params. Always at least the original id. */
+export function userIdIn(db, column, userId) {
+    const ids = equivalentUserIds(db, userId);
+    return {
+        clause: `${column} IN (${ids.map(() => "?").join(",")})`,
+        params: ids,
+    };
+}

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

@@ -0,0 +1,100 @@
+/**
+ * In-memory implementation of IdentityRepo — for tests and embedded scenarios.
+ *
+ * §4.5 静默折叠声明：
+ *   - 错误（duplicate / FK violation）一律 throw，不静默吞
+ *   - PK 校验在内存层用 Map.set 覆盖语义，会污染 — 故显式 if-exist check + throw
+ */
+export class InMemoryIdentityRepo {
+    identities = new Map();
+    aliases = new Map(); // key = `${platform}:${platform_user_id}`
+    managers = new Map(); // user_id → manager_user_id
+    async createIdentity(input) {
+        if (this.identities.has(input.libero_user_id)) {
+            throw new Error(`identity already exists: libero_user_id=${input.libero_user_id}`);
+        }
+        const now = new Date().toISOString();
+        const row = {
+            libero_user_id: input.libero_user_id,
+            display_name: input.display_name ?? null,
+            created_at: now,
+            updated_at: now,
+        };
+        this.identities.set(input.libero_user_id, row);
+        return input.libero_user_id;
+    }
+    async getIdentity(libero_user_id) {
+        return this.identities.get(libero_user_id) ?? null;
+    }
+    async bindAlias(input) {
+        // FK check
+        if (!this.identities.has(input.libero_user_id)) {
+            throw new Error(`bindAlias FK violation: libero_user_id not found: ${input.libero_user_id}`);
+        }
+        // PK check
+        const key = `${input.platform}:${input.platform_user_id}`;
+        if (this.aliases.has(key)) {
+            throw new Error(`alias already bound: platform=${input.platform} platform_user_id=${input.platform_user_id}`);
+        }
+        const row = {
+            libero_user_id: input.libero_user_id,
+            platform: input.platform,
+            platform_user_id: input.platform_user_id,
+            chat_id: input.chat_id ?? input.platform_user_id,
+            bound_at: new Date().toISOString(),
+        };
+        this.aliases.set(key, row);
+    }
+    async listAliases(libero_user_id) {
+        const out = [];
+        for (const alias of this.aliases.values()) {
+            if (alias.libero_user_id === libero_user_id)
+                out.push(alias);
+        }
+        return out;
+    }
+    async findAliasByPlatformUserId(platform_user_id) {
+        for (const alias of this.aliases.values()) {
+            if (alias.platform_user_id === platform_user_id)
+                return alias;
+        }
+        return null;
+    }
+    async listAllIdentities() {
+        return Array.from(this.identities.values()).map((i) => ({
+            ...i,
+            managed_by: this.managers.get(i.libero_user_id) ?? null,
+        }));
+    }
+    async getManager(libero_user_id) {
+        const id = this.identities.get(libero_user_id);
+        if (!id) {
+            throw new Error(`getManager: libero_user_id not found: ${libero_user_id}`);
+        }
+        const managedBy = this.managers.get(libero_user_id) ?? null;
+        const mgr = managedBy ? this.identities.get(managedBy) : null;
+        return {
+            libero_user_id,
+            managed_by: managedBy,
+            manager_display_name: mgr?.display_name ?? null,
+        };
+    }
+    async setManager(input) {
+        if (!this.identities.has(input.libero_user_id)) {
+            throw new Error(`setManager: libero_user_id not found: ${input.libero_user_id}`);
+        }
+        if (input.managed_by !== null) {
+            if (!this.identities.has(input.managed_by)) {
+                throw new Error(`setManager: manager libero_user_id not found: ${input.managed_by}`);
+            }
+            this.managers.set(input.libero_user_id, input.managed_by);
+        }
+        else {
+            this.managers.delete(input.libero_user_id);
+        }
+        return {
+            libero_user_id: input.libero_user_id,
+            managed_by: input.managed_by,
+        };
+    }
+}

package/dist/mcp/src/identity/resolve.js

@@ -0,0 +1,60 @@
+import { randomUUID } from "node:crypto";
+/**
+ * S40 兼容层核心：把任意 user_id 输入（libero_user_id / platform chat_id / 旧数据 chat_id）
+ * 解析成稳定的 libero_user_id。
+ *
+ * 三段查找：
+ *   1. user_platform_alias 表：input 是某平台的 platform_user_id？→ 返回 libero_user_id
+ *   2. user_identity 表：input 本身就是 libero_user_id？→ 直接返回
+ *   3. 都不是 → 视为旧数据 chat_id，自动建对应 identity + alias 兜底行（platform='unknown'）
+ *
+ * §4.5 静默折叠声明：
+ *   - "自动建 identity" 是显式声明的折叠——意图是兼容旧数据（slice 1 不全量 update 业务表）
+ *   - 副作用：未知 chat_id 第一次出现会建一个新 libero user，永远不会跟已有用户合并
+ *   - 主会话需通过 profile.bindAlias 主动声明合并（用户首接触多设备时引导）
+ *
+ * 幂等：第二次同 chat_id 调用会命中步骤 1，不会重复建 identity。
+ */
+export async function resolveUserId(repo, input) {
+    if (!input) {
+        throw new Error("resolveUserId: input is required");
+    }
+    // 1. platform_user_id?
+    const alias = await repo.findAliasByPlatformUserId(input);
+    if (alias)
+        return alias.libero_user_id;
+    // 2. libero_user_id?
+    const identity = await repo.getIdentity(input);
+    if (identity)
+        return input;
+    // 3. legacy chat_id — auto-create
+    const newLiberoId = `u_libero_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
+    const displayName = input.length <= 16 ? input : input.slice(0, 16);
+    await repo.createIdentity({
+        libero_user_id: newLiberoId,
+        display_name: displayName,
+    });
+    await repo.bindAlias({
+        libero_user_id: newLiberoId,
+        platform: detectPlatformFromId(input),
+        platform_user_id: input,
+        chat_id: input,
+    });
+    return newLiberoId;
+}
+/**
+ * 平台探测（heuristic）：
+ *   - slice 1 不强求精确；返回 'unknown' 是安全默认，主会话首次接触时让用户确认
+ *   - 未来可扩展为更精确的模式匹配
+ */
+export function detectPlatformFromId(id) {
+    // wecom chat_id 通常 'wm_' / 'woqoaa' 开头，长度 30-32
+    if (/^(wm_|woqoaa|wm_)/.test(id) || (id.length >= 30 && id.length <= 32 && /^[A-Za-z0-9_-]+$/.test(id))) {
+        return "wecom";
+    }
+    // feishu open_id 通常 'ou_' 开头
+    if (/^ou_[a-f0-9]{40,}$/i.test(id)) {
+        return "feishu";
+    }
+    return "unknown";
+}

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

@@ -0,0 +1,4 @@
+// ============================================================
+// S40 cross-platform identity domain types
+// ============================================================
+export {};

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

@@ -0,0 +1,15 @@
+export function createMatrixTools(repo) {
+    return {
+        async renderMatrix(filters) {
+            if (!filters.user_id) {
+                throw new Error("user_id 为必填参数");
+            }
+            if (filters.from !== undefined &&
+                filters.to !== undefined &&
+                filters.from > filters.to) {
+                throw new Error("开始时间不能晚于结束时间");
+            }
+            return repo.renderMatrix(filters);
+        },
+    };
+}

package/dist/mcp/src/profile/confirm-default.js

@@ -0,0 +1,48 @@
+export function createProfileConfirmTools(db) {
+    return {
+        async confirmDefault(input) {
+            if (!input.platform_user_id || !input.platform_user_id.trim()) {
+                throw new Error("platform_user_id 为必填参数");
+            }
+            if (!input.display_name || !input.display_name.trim()) {
+                throw new Error("display_name 为必填参数");
+            }
+            const displayName = input.display_name.trim();
+            const platformUserId = input.platform_user_id.trim();
+            const taken = db
+                .prepare(`SELECT id FROM user_profile
+           WHERE display_name = ? AND id != ? AND deleted_at IS NULL`)
+                .get(displayName, platformUserId);
+            if (taken) {
+                return { status: "rejected", reason: "display_name_taken" };
+            }
+            const now = new Date().toISOString().replace("T", " ").replace("Z", "");
+            const existing = db
+                .prepare(`SELECT id FROM user_profile WHERE id = ? AND deleted_at IS NULL`)
+                .get(platformUserId);
+            if (existing) {
+                db.prepare(`UPDATE user_profile
+           SET display_name = ?, default_confirmed_at = ?, updated_at = ?
+           WHERE id = ?`).run(displayName, now, now, platformUserId);
+            }
+            else {
+                db.prepare(`INSERT INTO user_profile
+             (id, display_name, expectations, settings, default_confirmed_at, created_at, updated_at)
+           VALUES (?, ?, NULL, NULL, ?, ?, ?)`).run(platformUserId, displayName, now, now, now);
+            }
+            const row = db
+                .prepare(`SELECT id, display_name, expectations, settings, default_confirmed_at, created_at, updated_at
+           FROM user_profile WHERE id = ?`)
+                .get(platformUserId);
+            return {
+                id: row.id,
+                display_name: row.display_name,
+                default_confirmed_at: row.default_confirmed_at,
+                expectations: row.expectations,
+                settings: row.settings != null ? JSON.parse(row.settings) : null,
+                created_at: row.created_at,
+                updated_at: row.updated_at,
+            };
+        },
+    };
+}