libero3 0.3.0

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

@@ -0,0 +1,298 @@
+import { randomUUID } from "node:crypto";
+async function pickReusableOrphan(repo, orphans) {
+    if (orphans.length === 0)
+        return undefined;
+    for (let i = orphans.length - 1; i >= 0; i--) {
+        const p = await repo.getById(orphans[i].libero_user_id);
+        const s = p?.settings;
+        if (s && Object.keys(s).length > 0)
+            return orphans[i];
+    }
+    return orphans.at(-1);
+}
+/** Validate and delegate profile operations to the repository.
+ *  ADR-0001: Dependency-injected — the caller provides the repo.
+ *
+ *  S41（2026-08-06）：新增可选 identityRepo 参数，用于 createUser 工具。
+ *  不传 = 不支持 createUser（向后兼容）。 */
+export function createProfileTools(repo, identityRepo) {
+    const dirty = async (userId) => {
+        if (typeof repo.markPortraitDirty === "function") {
+            await repo.markPortraitDirty(userId);
+        }
+    };
+    return {
+        async get(userId) {
+            if (!userId) {
+                throw new Error("user_id 为必填参数");
+            }
+            return repo.getById(userId);
+        },
+        async upsert(input) {
+            if (!input.user_id) {
+                throw new Error("user_id 为必填参数");
+            }
+            const p = await repo.upsert(input);
+            await dirty(input.user_id);
+            return p;
+        },
+        /**
+         * MV-COACH-3 slice 2（2026-07-31）：专门写 last_inactivity_nudge_at 时间戳。
+         *
+         * 解决问题：原本 LLM 触发"5 天没记录问候"后要自己调 profile.upsert 写这个时间戳，
+         * 但 LLM 经常忘调 → 5 天窗口防重复失效，可能 nag 多次。
+         * 专用工具 = 唯一入口，调别的没用，让"忘了写时间戳"在工具层不再可能。
+         *
+         * 关键：DEEP-MERGE 进 settings（不是 whole-replace），保留其它 settings key。
+         * （profile.upsert 的 settings 是 whole-replace per S13 §4，所以必须用专门工具。）
+         *
+         * nonexistent user_id 也会 auto-create profile row（防御 race / skill 顺序问题）。
+         *
+         * ⚠️ S40 slice 2（2026-08-02）：多 cron 并发时不要用 markInactivityNudge（无 atomic 保护）。
+         * 用 claimNudge —— 它有 atomic 防重复（window 内只有一方赢）。
+         * markInactivityNudge 留作单 cron 场景（产品叙事：单渠道 cron + nag 历史判定）。
+         */
+        async markInactivityNudge(input) {
+            if (!input.user_id) {
+                throw new Error("user_id 为必填参数");
+            }
+            const now = new Date().toISOString();
+            const existing = await repo.getById(input.user_id);
+            const existingSettings = existing?.settings != null
+                ? existing.settings
+                : {};
+            const merged = {
+                ...existingSettings,
+                last_inactivity_nudge_at: now,
+            };
+            return repo.upsert({
+                user_id: input.user_id,
+                settings: merged,
+            });
+        },
+        /**
+         * S40 slice 2 → slice 3（2026-08-03 升级）：Atomic claim。
+         *
+         * 历史：slice 2 是 tool 层「读-检查-写」，集成测试量出 100% race（每次并发都双发）。
+         * slice 3 改为：repo 提供 claimNudgeAtomic（用 better-sqlite3 db.transaction 包整段）。
+         *
+         * 兼容降级：如果 repo 没实现 claimNudgeAtomic（如 InMemoryProfileRepo），
+         * 走旧版非原子逻辑——但会在 §4.5 静默折叠意义上「未声明」，所以打 WARN 日志。
+         *
+         * @4.5 显式声明：sqlite transaction 是真 atomic（阻塞 event loop + 写锁）。
+         * 在 in-memory repo 下无 atomic 保护——但 in-memory 只在测试场景，无生产风险。
+         */
+        async claimNudge(input) {
+            if (!input.user_id) {
+                throw new Error("user_id 为必填参数");
+            }
+            const windowMinutes = input.window_minutes ?? 5;
+            // 优先用 repo 提供的 atomic 版本（sqlite production path）
+            if (typeof repo.claimNudgeAtomic === "function") {
+                return repo.claimNudgeAtomic({
+                    user_id: input.user_id,
+                    window_minutes: windowMinutes,
+                });
+            }
+            // 兼容降级（in-memory / 测试）：非原子，无并发安全保证
+            // ⚠️ §4.5 声明：此分支不是 atomic，仅用于无并发的测试场景
+            // eslint-disable-next-line no-console
+            console.warn("[claimNudge] repo.claimNudgeAtomic 未实现，降级到非原子路径。" +
+                "仅测试场景安全，生产必须用 SqliteProfileRepo。");
+            const windowMs = windowMinutes * 60 * 1000;
+            const now = new Date();
+            const nowIso = now.toISOString();
+            const existing = await repo.getById(input.user_id);
+            const existingSettings = existing?.settings != null
+                ? existing.settings
+                : {};
+            const lastNudgeAt = existingSettings.last_inactivity_nudge_at;
+            if (typeof lastNudgeAt === "string") {
+                const ageMs = now.getTime() - new Date(lastNudgeAt).getTime();
+                if (ageMs < windowMs) {
+                    return { won: false, profile: existing };
+                }
+            }
+            const merged = {
+                ...existingSettings,
+                last_inactivity_nudge_at: nowIso,
+            };
+            const profile = await repo.upsert({
+                user_id: input.user_id,
+                settings: merged,
+            });
+            return { won: true, profile };
+        },
+        /**
+         * S41（2026-08-06）：建新 libero 用户（管理员代管模式）。
+         *
+         * 产品定位：「帮我建一个新用户」「我要给我儿子建档」时调用。
+         * 无 user_id：不查重（同名不冲突）。有 user_id（家长）：同名孩子复用并自动 setManager。
+         *
+         * 必须传 identityRepo 才可用（slice 1：server-core 启动时注入）。
+         *
+         * 输入校验（§4.5 显式）：
+         *   - display_name 必填非空
+         *   - platform 和 platform_user_id 必须同时给或同时不给
+         *
+         * 副作用：建 identity → 建 profile（空白）→ （可选）绑 alias
+         * 失败语义：identity 建成功但 profile 建失败 → 抛错，identity 留在表里
+         *   （可接受：identity 没有 profile 也能用，下次 profile.get 会触发 auto-create；
+         *    不做事务回滚是 §3 #4 最小可逆单位原则。）
+         */
+        async createUser(input) {
+            if (!identityRepo) {
+                throw new Error("createUser 需要 identityRepo（server-core 启动时未注入，本部署不支持多用户建档）");
+            }
+            if (!input.display_name || input.display_name.trim() === "") {
+                throw new Error("display_name 为必填参数且不能为空");
+            }
+            const display_name = input.display_name.trim();
+            const hasPlatform = !!input.platform;
+            const hasPlatformUserId = !!input.platform_user_id;
+            if (hasPlatform !== hasPlatformUserId) {
+                throw new Error("platform 和 platform_user_id 必须同时给或同时不给（绑定平台 alias 时两者都需要）");
+            }
+            const managerId = input.user_id?.trim() || "";
+            if (managerId) {
+                if (!(await identityRepo.getIdentity(managerId))) {
+                    await identityRepo.createIdentity({
+                        libero_user_id: managerId,
+                        display_name: managerId,
+                    });
+                }
+                const all = await identityRepo.listAllIdentities();
+                const mine = all.filter((i) => (i.display_name ?? "").trim() === display_name &&
+                    i.managed_by === managerId);
+                const orphans = all.filter((i) => (i.display_name ?? "").trim() === display_name &&
+                    !i.managed_by &&
+                    i.libero_user_id !== managerId);
+                const hit = mine.at(-1) ?? (await pickReusableOrphan(repo, orphans));
+                if (hit) {
+                    const settings = {};
+                    if (input.focus_areas && input.focus_areas.length > 0) {
+                        settings.focus_areas = input.focus_areas;
+                    }
+                    if (input.goals && input.goals.trim() !== "") {
+                        settings.goals = input.goals;
+                    }
+                    const existing = await repo.getById(hit.libero_user_id);
+                    const merged = {
+                        ...(existing?.settings ?? {}),
+                        ...settings,
+                    };
+                    await repo.upsert({
+                        user_id: hit.libero_user_id,
+                        display_name,
+                        settings: Object.keys(merged).length > 0 ? merged : undefined,
+                    });
+                    if (hit.managed_by !== managerId) {
+                        await identityRepo.setManager({
+                            libero_user_id: hit.libero_user_id,
+                            managed_by: managerId,
+                        });
+                    }
+                    await dirty(hit.libero_user_id);
+                    await dirty(managerId);
+                    return {
+                        libero_user_id: hit.libero_user_id,
+                        display_name,
+                        reused: true,
+                    };
+                }
+            }
+            const libero_user_id = `u_libero_${randomUUID().replace(/-/g, "").slice(0, 16)}`;
+            await identityRepo.createIdentity({
+                libero_user_id,
+                display_name,
+            });
+            const settings = {};
+            if (input.focus_areas && input.focus_areas.length > 0) {
+                settings.focus_areas = input.focus_areas;
+            }
+            if (input.goals && input.goals.trim() !== "") {
+                settings.goals = input.goals;
+            }
+            await repo.upsert({
+                user_id: libero_user_id,
+                display_name,
+                settings: Object.keys(settings).length > 0 ? settings : undefined,
+            });
+            await dirty(libero_user_id);
+            if (managerId) {
+                await identityRepo.setManager({
+                    libero_user_id,
+                    managed_by: managerId,
+                });
+                await dirty(managerId);
+            }
+            let bound_alias;
+            if (hasPlatform && hasPlatformUserId) {
+                await identityRepo.bindAlias({
+                    libero_user_id,
+                    platform: input.platform,
+                    platform_user_id: input.platform_user_id,
+                    chat_id: input.chat_id,
+                });
+                bound_alias = {
+                    platform: input.platform,
+                    platform_user_id: input.platform_user_id,
+                    chat_id: input.chat_id ?? null,
+                };
+            }
+            return {
+                libero_user_id,
+                display_name,
+                bound_alias,
+            };
+        },
+        /**
+         * S43（2026-08-07）：列出所有 libero 用户。
+         * 用途：扫描 cron 跑所有用户的状态升级和主动询问（不靠 LLM 从上下文猜）。
+         *
+         * 数据源：identity 表（libero 内部身份）。display_name 取 identity 表的。
+         * §4.5 静默折叠声明：返回所有 identity 行；若 identityRepo 未注入则抛（不静默返回空）。
+         */
+        async listAllUsers() {
+            if (!identityRepo) {
+                throw new Error("listAllUsers 需要 identityRepo（server-core 启动时未注入，本部署不支持多用户扫描）");
+            }
+            const identities = await identityRepo.listAllIdentities();
+            return identities.map((i) => ({
+                libero_user_id: i.libero_user_id,
+                display_name: i.display_name,
+            }));
+        },
+        /**
+         * S44（2026-08-07）：查某用户的代管人。
+         * 用途：扫描 cron 发现用户没自己渠道时，查 managed_by 把追问发给代管人。
+         */
+        async getManager(input) {
+            if (!identityRepo) {
+                throw new Error("getManager 需要 identityRepo（本部署不支持代管转发）");
+            }
+            if (!input.user_id) {
+                throw new Error("user_id 为必填参数");
+            }
+            return identityRepo.getManager(input.user_id);
+        },
+        /**
+         * S44（2026-08-07）：设置/清除某用户的代管人。
+         * managed_by=null 清除；非 null 必须指向存在的 libero_user_id。
+         */
+        async setManager(input) {
+            if (!identityRepo) {
+                throw new Error("setManager 需要 identityRepo（本部署不支持代管转发）");
+            }
+            if (!input.user_id) {
+                throw new Error("user_id 为必填参数");
+            }
+            const result = await identityRepo.setManager({
+                libero_user_id: input.user_id,
+                managed_by: input.managed_by,
+            });
+            await dirty(input.user_id);
+            return result;
+        },
+    };
+}

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

@@ -0,0 +1,28 @@
+import { platformDefaultDisplayName } from "./profile-helpers.js";
+function buildNeedsConfirm(platformUserId) {
+    return {
+        status: "needs_confirm",
+        platform_user_id: platformUserId,
+        suggested_display_name: platformDefaultDisplayName(platformUserId),
+    };
+}
+/**
+ * Check user_profile for platformUserId.
+ * @returns null if confirmed/exists; NeedsConfirm if missing (caller must not write).
+ */
+export function assertProfileConfirmed(db, platformUserId) {
+    const row = db
+        .prepare(`SELECT id FROM user_profile WHERE id = ? AND deleted_at IS NULL`)
+        .get(platformUserId);
+    if (row)
+        return null;
+    return buildNeedsConfirm(platformUserId);
+}
+/**
+ * Same gate when caller only has a boolean from repo.userExists().
+ */
+export function needsConfirmIfMissing(exists, platformUserId) {
+    if (exists)
+        return null;
+    return buildNeedsConfirm(platformUserId);
+}

package/dist/mcp/src/profile-helpers.js

@@ -0,0 +1,109 @@
+/** Slice 2: effective user = target_user_id ?? user_id */
+export function effectiveUserId(input) {
+    return input.target_user_id ?? input.user_id;
+}
+/** Slice 5: label for brain replies — display_name or last 4 of id */
+export function resolveTargetUserLabel(userId, displayName) {
+    const name = displayName?.trim();
+    if (name)
+        return name;
+    return userId.slice(-4) || userId;
+}
+export function lookupTargetUserLabel(db, userId) {
+    const row = db
+        .prepare(`SELECT display_name FROM user_profile WHERE id = ? AND deleted_at IS NULL`)
+        .get(userId);
+    return resolveTargetUserLabel(userId, row?.display_name);
+}
+function rowToProfile(row) {
+    return {
+        id: row.id,
+        display_name: row.display_name,
+        expectations: row.expectations,
+        settings: row.settings != null
+            ? JSON.parse(row.settings)
+            : null,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+}
+/** Platform default display_name: e.g. wecom:woqoa1b2xyz → wecom_2xyz */
+export function platformDefaultDisplayName(platformUserId) {
+    const colon = platformUserId.indexOf(":");
+    if (colon > 0) {
+        const platform = platformUserId.slice(0, colon);
+        const rest = platformUserId.slice(colon + 1);
+        const suffix = rest.slice(-4) || rest || "user";
+        return `${platform}_${suffix}`;
+    }
+    const suffix = platformUserId.slice(-4) || platformUserId || "user";
+    return suffix;
+}
+/**
+ * Exact match on display_name.
+ * 0 → null; 1 → Profile; 2+ → Profile[] (diagnostic).
+ */
+export function findProfileByDisplayName(db, displayName) {
+    const rows = db
+        .prepare(`SELECT id, display_name, expectations, settings, created_at, updated_at
+       FROM user_profile
+       WHERE display_name = ? AND deleted_at IS NULL`)
+        .all(displayName);
+    if (rows.length === 0)
+        return null;
+    if (rows.length === 1)
+        return rowToProfile(rows[0]);
+    return rows.map(rowToProfile);
+}
+/**
+ * Ensure a profile row exists for platformUserId (PK = platform id).
+ * Missing display_name → fill platform default (e.g. wecom_a1b2).
+ */
+export function getOrCreateDefaultProfile(db, platformUserId) {
+    const existing = db
+        .prepare(`SELECT id, display_name, expectations, settings, created_at, updated_at
+       FROM user_profile
+       WHERE id = ? AND deleted_at IS NULL`)
+        .get(platformUserId);
+    if (existing) {
+        if (!existing.display_name || existing.display_name.trim() === "") {
+            const filled = platformDefaultDisplayName(platformUserId);
+            const now = new Date().toISOString().replace("T", " ").replace("Z", "");
+            db.prepare(`UPDATE user_profile SET display_name = ?, updated_at = ? WHERE id = ?`).run(filled, now, platformUserId);
+            return rowToProfile({ ...existing, display_name: filled, updated_at: now });
+        }
+        return rowToProfile(existing);
+    }
+    const displayName = platformDefaultDisplayName(platformUserId);
+    const now = new Date().toISOString().replace("T", " ").replace("Z", "");
+    db.prepare(`INSERT INTO user_profile (id, display_name, expectations, settings, created_at, updated_at)
+     VALUES (?, ?, NULL, NULL, ?, ?)`).run(platformUserId, displayName, now, now);
+    return {
+        id: platformUserId,
+        display_name: displayName,
+        expectations: null,
+        settings: null,
+        created_at: now,
+        updated_at: now,
+    };
+}
+/**
+ * Resolve target display name → user_id.
+ * platformUserId is reserved for caller context (not used for matching —
+ * display_name uniqueness is enforced by confirm_default).
+ */
+export function resolveTargetUser(db, input) {
+    void input.platformUserId;
+    const found = findProfileByDisplayName(db, input.targetDisplayName);
+    if (found === null) {
+        return { kind: "not_found", query: input.targetDisplayName };
+    }
+    if (Array.isArray(found)) {
+        return { kind: "ambiguous", matches: found };
+    }
+    return {
+        kind: "resolved",
+        userId: found.id,
+        displayName: found.display_name,
+    };
+}

package/dist/mcp/src/reminder/hermes-channel.js

@@ -0,0 +1,40 @@
+/**
+ * HermesChannel — delivers reminders via `hermes send -t <target>` (T2).
+ *
+ * Uses CommandRunner abstraction (default: child_process.spawn, arrays only — no shell injection).
+ * DI `run` for testability; env HERMES_BIN overrides the binary path.
+ */
+import { spawn } from "node:child_process";
+/** Default runner: spawn `hermes` (HERMES_BIN override or PATH) with array args. */
+function defaultRunner(args) {
+    const bin = process.env.HERMES_BIN || "hermes";
+    return new Promise((resolve) => {
+        const child = spawn(bin, args, { stdio: "ignore" });
+        child.on("close", (code) => resolve(code ?? 1));
+        child.on("error", () => resolve(1));
+    });
+}
+export class HermesChannel {
+    defaultTarget;
+    run;
+    constructor(opts) {
+        this.defaultTarget = opts?.defaultTarget;
+        this.run = opts?.run ?? defaultRunner;
+    }
+    async send(r) {
+        // LLM 注入优先：只有 platform:address 格式（含 ':'）才算有效 direct target。
+        // 'session' / '' / 无 ':' → 视为无 direct target，走 defaultTarget 常量兜底。
+        const direct = r.channel && r.channel.includes(":") ? r.channel : null;
+        const target = direct ?? this.defaultTarget;
+        // §4.5 静默折叠：无送达目标 → warn + return false。
+        // 吞掉的原因：reminder 可能由无渠道上下文的途径创建（如 session fallback），
+        // 或 schema default='session' 且 LLM 未注入有效 channel。
+        if (!target) {
+            console.warn(`[HermesChannel] no target for reminder ${r.id}`);
+            return false;
+        }
+        const code = await this.run(["send", "-t", target, r.content]);
+        // 不抛——失败交 reminder-tick 的 releaseOrFail 重试/死信。
+        return code === 0;
+    }
+}

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

@@ -0,0 +1,70 @@
+import { nowLocal } from "../clock/index.js";
+import { needsConfirmIfMissing, } from "../profile-confirm.js";
+import { lookupTargetUserLabel, resolveTargetUserLabel, } from "../profile-helpers.js";
+/**
+ * Validate and delegate reminder operations to the repository.
+ * ADR-0001: Dependency-injected — the caller provides the repo.
+ *
+ * @param repo  ReminderRepo implementation
+ * @param getNow  Clock injection for determinism; defaults to clock.nowLocal()
+ * @param db  optional — enables display_name lookup for target_user_label
+ */
+export function createReminderTools(repo, getNow, db) {
+    const now = getNow ?? (() => nowLocal());
+    const create = async (input) => {
+        if (!input.content || input.content.trim() === "") {
+            throw new Error("提醒内容不能为空");
+        }
+        // 2026-09-08 修复：曾用字符串比较，Z 结尾 UTC 会被误判"早于当前时间"（该坑
+        // 已写进 WorkBuddy SKILL 当铁律）。改为时间戳比较，任意 ISO 时区格式均可。
+        const remindAtMs = Date.parse(input.remind_at);
+        if (Number.isNaN(remindAtMs)) {
+            throw new Error("remind_at 无法解析为时间（需 ISO 8601）");
+        }
+        if (remindAtMs <= Date.parse(now())) {
+            throw new Error("提醒时间不能早于当前时间");
+        }
+        const userId = input.target_user_id ?? input.user_id;
+        const userOk = await repo.userExists(userId);
+        const gate = needsConfirmIfMissing(userOk, userId);
+        if (gate)
+            return gate;
+        const row = await repo.create({
+            user_id: userId,
+            content: input.content,
+            remind_at: input.remind_at,
+            channel: input.channel,
+            timeblock_id: input.timeblock_id,
+        });
+        const label = db
+            ? lookupTargetUserLabel(db, userId)
+            : resolveTargetUserLabel(userId);
+        return { ...row, target_user_label: label };
+    };
+    const getDueReminders = async (input) => {
+        return repo.getDueReminders({
+            user_id: input.user_id,
+            until: input.until ?? now(),
+        });
+    };
+    const getNextDue = async (input) => {
+        return repo.getNextDue(input ?? {});
+    };
+    const getMissedReminders = async (input) => {
+        return repo.getMissedReminders({ ...input, now: now() });
+    };
+    const markSent = async (id) => {
+        return repo.markSent(id);
+    };
+    const cancelReminder = async (id) => {
+        return repo.cancelReminder(id);
+    };
+    return {
+        create,
+        getDueReminders,
+        getNextDue,
+        getMissedReminders,
+        markSent,
+        cancelReminder,
+    };
+}

package/dist/mcp/src/reminder/push-channel.js

@@ -0,0 +1,10 @@
+/**
+ * LogChannel — development fallback. Prints to console, always returns true.
+ * No real delivery; used when no credentials are configured.
+ */
+export class LogChannel {
+    async send(r) {
+        console.log(`[reminder] ${r.content} @ ${r.remind_at}`);
+        return true;
+    }
+}

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

@@ -0,0 +1,34 @@
+import { SqliteCategoryRepo, SqliteTimeBlockRepo, SqliteStatsRepo, SqliteTimerRepo, SqliteProfileRepo, SqliteReminderRepo, SqliteTimelineRepo, } from "./sqlite.js";
+import { SqliteIdentityRepo } from "./sqlite-identity.js";
+import { SqliteApRepo } from "./sqlite-ap.js";
+/**
+ * Build the full repo set for a given Database connection.
+ *
+ * impl resolution order: opts.impl → process.env.LIBERO_REPO_IMPL → 'sqlite'.
+ * Throws on any non-'sqlite' value (Postgres is a placeholder, not yet implemented).
+ */
+export function createRepos(db, opts) {
+    const impl = resolveImpl(opts);
+    if (impl !== "sqlite") {
+        throw new Error(`LIBERO_REPO_IMPL='${impl}' not implemented yet (only 'sqlite' supported)`);
+    }
+    return {
+        categoryRepo: new SqliteCategoryRepo(db),
+        timeblockRepo: new SqliteTimeBlockRepo(db),
+        statsRepo: new SqliteStatsRepo(db),
+        timerRepo: new SqliteTimerRepo(db),
+        profileRepo: new SqliteProfileRepo(db),
+        reminderRepo: new SqliteReminderRepo(db),
+        timelineRepo: new SqliteTimelineRepo(db),
+        identityRepo: new SqliteIdentityRepo(db),
+        apRepo: new SqliteApRepo(db),
+    };
+}
+function resolveImpl(opts) {
+    if (opts?.impl)
+        return opts.impl;
+    const fromEnv = process.env.LIBERO_REPO_IMPL;
+    if (fromEnv)
+        return fromEnv;
+    return "sqlite";
+}