libero3 0.3.0

package/dist/knowledge/brain-science/brain-extended-mind.yaml

@@ -0,0 +1,22 @@
+id: brain-extended-mind
+kind: prescription
+dimension: brain-science
+title: 用身体思考
+triggers:
+  signals:
+    - quadrant: 能耗黑洞
+  symptoms:
+    - 卡壳
+    - 灵感枯竭
+prescription:
+  one_liner: 卡住时立刻起身走 10 分钟 + 手写关键问题 + 找人讲一遍
+  steps:
+    - 卡住时立刻起身
+    - 走 10 分钟（不戴耳机）
+    - 手写关键问题或找人讲一遍
+  micro_experiment: 下次卡壳时起身走 10 分钟
+  verify: 走动后是否能突破卡壳点
+source:
+  ref: The Extended Mind (Annie Murphy Paul)
+evidence_level: book
+tags: [认知, 身体]

package/dist/knowledge/brain-science/brain-friction-barrier.yaml

@@ -0,0 +1,22 @@
+id: brain-friction-barrier
+kind: prescription
+dimension: brain-science
+title: 增加行为摩擦力
+triggers:
+  signals:
+    - quadrant: 能耗黑洞
+  symptoms:
+    - 刷视频/游戏过度
+    - 失控刷手机
+prescription:
+  one_liner: 手机放另一个房间充电 + App 设时间限制 + 卸载最常刷的那个
+  steps:
+    - 手机放另一个房间充电
+    - 给最常刷的 App 设时间限制
+    - 考虑卸载最常刷的那个
+  micro_experiment: 今晚手机放客厅充电，卧室不放手机
+  verify: 一天中无意识刷手机的时长变化
+source:
+  ref: 《多巴胺国度》(Dopamine Nation, Anna Lembke)
+evidence_level: book
+tags: [多巴胺, 行为设计]

package/dist/knowledge/brain-science/brain-peak-end.yaml

@@ -0,0 +1,29 @@
+id: brain-peak-end
+kind: prescription
+dimension: brain-science
+title: 峰终定律——用峰值体验+强收尾设计子任务序列
+triggers:
+  signals:
+    - quadrant: 能耗黑洞
+  symptoms:
+    - 长时间无正反馈
+    - 任务中途放弃
+    - 做完一大块却没成就感
+prescription:
+  one_liner: 把子任务序列排成 前置一个快速小胜做峰 + 结尾一个可庆祝收尾做终
+  steps:
+    - 前端放一个 ≤5 分钟就能拿下的冷启动小胜，制造正反馈峰值
+    - 中段按循序渐进排，单块 ≤25 分钟
+    - 收尾子任务设计成明确完成、可庆祝的形态（如产出草稿或提交一次）
+    - 每完成一块立刻标记加一句鼓励，强化峰终记忆
+  micro_experiment: 选一个大任务，把第一块拆成 5 分钟内能拿下的小胜，做完立刻庆祝，观察后续启动阻力
+  verify: 序列完成后，主观成就感与干劲是否高于平铺直叙地做
+source:
+  ref: 峰终定律（Kahneman, Fredrickson, Schreiber & Redelmeier, 1993）
+evidence_level: research-observational
+evidence_note: 原研究针对事后体验评价（痛觉与噪声实验）；此处正向迁移到前向设计子任务序列，属合理外推而非直接 RCT
+applicability:
+  boundaries:
+    - 原理讲事后回忆，用于事前设计是外推，别当铁律
+    - 若任务本身无明确胜利点（纯重复劳动），峰终设计收益有限
+tags: [峰终定律, 正反馈, 子任务排序, 任务拆解]

package/dist/knowledge/brain-science/brain-pomodoro.yaml

@@ -0,0 +1,31 @@
+id: brain-pomodoro
+kind: prescription
+dimension: brain-science
+title: 番茄工作法
+triggers:
+  signals:
+    - quadrant: 能耗黑洞
+  symptoms:
+    - 碎片化严重
+    - 频繁切换
+    - 任务启动困难
+prescription:
+  one_liner: 25 分钟专注 + 5 分钟休息，休息期间集中回消息——既清了消息又不干扰专注
+  steps:
+    - 设定 25 分钟专注时段，只做一件事
+    - 时段内不切任务、不回消息（记到便签，不立刻处理）
+    - 5 分钟休息时集中处理积累的消息
+    - 循环
+  micro_experiment: 明天用一次番茄钟——25 分钟只做一件事，休息 5 分钟集中回消息
+  verify: 一天中任务切换次数是否下降、专注时段产出感知是否提升
+source:
+  ref: 番茄工作法 (The Pomodoro Technique, Francesco Cirillo)
+evidence_level: framework
+evidence_note: 方法论框架，非单一 RCT 证据；P4 碎片化诊断的三个标准选项之一（另两个为环境工程/深度工作块）
+applicability:
+  personas_fit: []
+  personas_avoid: []
+  boundaries:
+    - 对被强同步约束岗位（如客服、即时响应），25 分钟不可达窗口可能不现实
+    - 专注时长可按个人调整（部分人更适合 50/10 配比）
+tags: [专注, 切换成本, 碎片化]

package/dist/knowledge/brain-science/brain-revenge-bedtime.yaml

@@ -0,0 +1,22 @@
+id: brain-revenge-bedtime
+kind: prescription
+dimension: brain-science
+title: 给转场时刻设替代动作
+triggers:
+  signals:
+    - quadrant: 能耗黑洞
+  symptoms:
+    - 报复性熬夜
+    - 不想结束这一天
+prescription:
+  one_liner: 睡前 1 小时启动固定流程：断屏 → 洗漱 → 读纸质书 10 页
+  steps:
+    - 设定睡前 1 小时的闹钟
+    - 断屏（手机放客厅）
+    - 洗漱 → 读纸质书 10 页
+  micro_experiment: 今晚睡前 1 小时断屏+洗漱+读纸质书 10 页
+  verify: 实际入睡时间是否提前
+source:
+  ref: Indistractable (Nir Eyal)
+evidence_level: book
+tags: [睡眠, 习惯设计]

package/dist/knowledge/brain-science/brain-single-variable.yaml

@@ -0,0 +1,15 @@
+id: brain-single-variable
+kind: principle
+dimension: brain-science
+title: 单一动作原则
+triggers:
+  symptoms:
+    - 想全部改
+    - 多个痛点同时存在
+prescription:
+  one_liner: 一个微实验只含一个核心动作，等复查确认稳了再加第二个
+  micro_experiment: 每次只执行一个微实验
+source:
+  ref: libero 内部设计原则（来自 coaching-framework §5.3）
+evidence_level: framework
+tags: [方法论, 单一变量]

package/dist/knowledge/brain-science/brain-tiny-habits.yaml

@@ -0,0 +1,22 @@
+id: brain-tiny-habits
+kind: prescription
+dimension: brain-science
+title: B=MAP 微习惯配方
+triggers:
+  signals:
+    - quadrant: 能耗黑洞
+  symptoms:
+    - 拖延
+    - 任务反复无进展
+prescription:
+  one_liner: "After 我[现有行为], I will [30秒微动作] + 完成立刻握拳庆祝"
+  steps:
+    - 找到锚点行为（你已经在做的事）
+    - 设计 ≤30 秒的微动作
+    - 完成立刻庆祝
+  micro_experiment: 设计一个 B=MAP 微习惯配方，试 3 天
+  verify: 微习惯的连续完成天数
+source:
+  ref: 《福格行为模型》(Tiny Habits, BJ Fogg)
+evidence_level: book
+tags: [习惯, 微习惯]

package/dist/knowledge/energy/energy-active-recovery.yaml

@@ -0,0 +1,22 @@
+id: energy-active-recovery
+kind: prescription
+dimension: energy
+title: 活动性恢复
+triggers:
+  signals:
+    - quadrant: 能耗黑洞
+  symptoms:
+    - 午后低效
+    - 下午犯困
+prescription:
+  one_liner: 每天下午安排一次 15 分钟散步/拉伸——不戴耳机，观察环境
+  steps:
+    - 下午 2-3 点安排 15 分钟恢复
+    - 散步或拉伸，不戴耳机
+    - 观察周围环境而非思考工作
+  micro_experiment: 明天下午安排 15 分钟不戴耳机的散步
+  verify: 散步后的精神状态和下午工作效率
+source:
+  ref: 《倦怠》(Burnout, Emily & Amelia Nagoski)
+evidence_level: book
+tags: [恢复, 精力循环]

package/dist/knowledge/energy/energy-deliberate-rest.yaml

@@ -0,0 +1,22 @@
+id: energy-deliberate-rest
+kind: prescription
+dimension: energy
+title: 刻意休息
+triggers:
+  signals:
+    - quadrant: 可放弃
+  symptoms:
+    - 周末恢复失效
+    - 刷屏式休息
+prescription:
+  one_liner: 用散步/手工/园艺等"活动性恢复"替代刷屏式休息
+  steps:
+    - 识别你的"假休息"行为（刷手机/追剧等）
+    - 替换为活动性恢复（散步/手工/园艺）
+    - 周末至少一次刻意休息
+  micro_experiment: 这个周末用一次散步替代一次刷手机
+  verify: 活动性恢复后的精力感知 vs 刷屏后的精力感知
+source:
+  ref: 《休息的艺术》(The Art of Rest, Claudia Hammond)
+evidence_level: book
+tags: [休息, 恢复]

package/dist/knowledge/energy/energy-exercise-embedded.yaml

@@ -0,0 +1,22 @@
+id: energy-exercise-embedded
+kind: prescription
+dimension: energy
+title: 运动嵌入日程
+triggers:
+  signals:
+    - quadrant: 可放弃
+  symptoms:
+    - 运动缺失
+    - 精力不足
+prescription:
+  one_liner: 从频率开始而非强度：每周固定 3 次，每次 20 分钟快走即可
+  steps:
+    - 选定每周 3 个固定时间
+    - 每次 20 分钟快走（不追求强度）
+    - 只关注"是否做了"不关注"做得多好"
+  micro_experiment: 本周固定 3 次 20 分钟快走
+  verify: 运动后精力感知是否改善
+source:
+  ref: 《运动改造大脑》(Spark, John Ratey)
+evidence_level: book
+tags: [运动, 精力]

package/dist/knowledge/energy/energy-fixed-wake-time.yaml

@@ -0,0 +1,22 @@
+id: energy-fixed-wake-time
+kind: prescription
+dimension: energy
+title: 先固化起床时间
+triggers:
+  signals:
+    - quadrant: 可放弃
+  symptoms:
+    - 睡眠缺失
+    - 作息混乱
+prescription:
+  one_liner: 连续两周固定起床时间（如 7:00），起床后立刻接触自然光 5 分钟；睡前一小时断屏
+  steps:
+    - 选定一个起床时间（如 7:00）
+    - 起床后立刻接触自然光 5 分钟
+    - 睡前一小时断屏
+  micro_experiment: 连续两周固定 7:00 起床+起床后自然光 5 分钟
+  verify: 两周后入睡时间和睡眠质量的变化
+source:
+  ref: 《为什么我们要睡觉》(Why We Sleep, Matthew Walker)
+evidence_level: book
+tags: [睡眠, 节律]

package/dist/knowledge/energy/energy-four-energy-radar.yaml

@@ -0,0 +1,22 @@
+id: energy-four-energy-radar
+kind: prescription
+dimension: energy
+title: 四类精力雷达图
+triggers:
+  signals:
+    - quadrant: 能耗黑洞
+  symptoms:
+    - 整体评分趋势下降
+    - 倦怠
+prescription:
+  one_liner: 身体/情绪/心智/意义各打分 1-10，找最低维度先修
+  steps:
+    - 给身体/情绪/心智/意义各打 1-10 分
+    - 找出最低维度
+    - 针对最低维度选一条处方
+  micro_experiment: 今晚给四类精力各打分，找出最低维度
+  verify: 一周后重新打分看是否改善
+source:
+  ref: 《精力管理》(The Power of Full Engagement, Jim Loehr & Tony Schwartz)
+evidence_level: book
+tags: [精力管理, 自评]

package/dist/knowledge/energy/energy-intensity-recovery.yaml

@@ -0,0 +1,22 @@
+id: energy-intensity-recovery
+kind: prescription
+dimension: energy
+title: 强度+恢复交替
+triggers:
+  signals:
+    - quadrant: 能耗黑洞
+  symptoms:
+    - 连续高强度无恢复
+    - 精力透支
+prescription:
+  one_liner: 高强度 1-1.5 小时后强制物理走动 5-10 分钟
+  steps:
+    - 设定 60-90 分钟高强度工作块
+    - 时间到强制起身物理走动 5-10 分钟
+    - 循环
+  micro_experiment: 明天每工作 90 分钟后强制走动 5 分钟
+  verify: 一天结束时的疲惫感是否低于平时
+source:
+  ref: Peak Performance (Brad Stulberg & Steve Magness)
+evidence_level: book
+tags: [恢复, 节奏]

package/dist/knowledge/scenario-packs/pack-summer-kid.yaml

@@ -0,0 +1,12 @@
+id: pack-summer-kid
+kind: scenario-pack
+title: 暑期计划（小学生）
+triggers:
+  context_tags: [小学生, 暑假, 帮孩子, 暑期, 孩子]
+recommends:
+  persona_id: kid-primary-school
+  analysis_model_ids: [review-summer-plan]
+  subskill_prompt: |
+    对象是小学生 + 家长协作：语言更具体、目标更小、
+    强调玩与学平衡、尊重孩子自主，不把家长焦虑转嫁孩子。
+description: 家长帮小学生规划/复盘暑假的情境包

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/knowledge/src/repo/types.js

@@ -0,0 +1 @@
+export {};

package/dist/knowledge/time/time-batch-windows.yaml

@@ -0,0 +1,22 @@
+id: time-batch-windows
+kind: prescription
+dimension: time
+title: 窗口期批处理
+triggers:
+  signals:
+    - quadrant: 能耗黑洞
+  symptoms:
+    - 浅薄工作占比大
+    - 消息太多
+prescription:
+  one_liner: 邮件/消息每天只在固定 2 个时段处理，其余时间默认不可达
+  steps:
+    - 选定 2 个批处理时段（如 11:00 和 16:00）
+    - 批处理时段集中回邮件/消息
+    - 其余时间关闭通知
+  micro_experiment: 明天只在 11:00 和 16:00 各花 15 分钟处理消息
+  verify: 一天中被消息打断的次数是否显著下降
+source:
+  ref: 《深度工作》(Deep Work, Cal Newport)
+evidence_level: book
+tags: [批处理, 消息管理]

package/dist/knowledge/time/time-conscious-abandon.yaml

@@ -0,0 +1,22 @@
+id: time-conscious-abandon
+kind: prescription
+dimension: time
+title: 有意识的放弃
+triggers:
+  signals:
+    - quadrant: 可放弃
+  symptoms:
+    - 可放弃事项多
+    - 做减法
+prescription:
+  one_liner: 选一个低分分类，直接砍掉或砍半。空出来的时间不填新东西——感受"留白"
+  steps:
+    - 找出可放弃象限中耗时最长但满意度最低的 1 个分类
+    - 直接砍掉或砍半
+    - 空出来的时间不填新东西
+  micro_experiment: 选一个低分分类砍掉，空出来的时间不填新东西
+  verify: 一周后看总耗时是否下降、满意度是否提升
+source:
+  ref: 《四千周》(Four Thousand Weeks, Oliver Burkeman)
+evidence_level: book
+tags: [做减法, 放弃]

package/dist/knowledge/time/time-deep-work-block.yaml

@@ -0,0 +1,22 @@
+id: time-deep-work-block
+kind: prescription
+dimension: time
+title: 深度工作块
+triggers:
+  signals:
+    - quadrant: 能耗黑洞
+  symptoms:
+    - 碎片化严重
+    - 频繁切换
+prescription:
+  one_liner: 每天锁定 1-1.5 小时无干扰深度时段：关通知、手机放抽屉、只做一件事
+  steps:
+    - 选定每天的深度时段（如上午 9:00-10:30）
+    - 关掉所有通知，手机放抽屉
+    - 只做一件需要深度思考的事
+  micro_experiment: 明天上午锁定 90 分钟无干扰深度工作，关通知+手机放抽屉
+  verify: 深度工作块后的产出感和满意度
+source:
+  ref: 《深度工作》(Deep Work, Cal Newport)
+evidence_level: book
+tags: [专注, 深度工作]

package/dist/knowledge/time/time-finite-commitment.yaml

@@ -0,0 +1,22 @@
+id: time-finite-commitment
+kind: prescription
+dimension: time
+title: 有限承诺清单
+triggers:
+  signals:
+    - quadrant: 能耗黑洞
+  symptoms:
+    - 承诺过多
+    - 焦虑忙乱
+prescription:
+  one_liner: 列出 3-5 个核心承诺，新任务进入前必须先挤掉一个旧的
+  steps:
+    - 写下当前所有在进行的承诺
+    - 只保留最重要的 3-5 个为"核心承诺层"
+    - 任何新任务进入，必须先从核心层挤掉一个
+  micro_experiment: 本周把活跃承诺压到 ≤5 个，新任务来必须先删一个旧的
+  verify: 一周后看高投入低满足分类的耗时是否下降
+source:
+  ref: 《四千周》(Four Thousand Weeks, Oliver Burkeman)
+evidence_level: book
+tags: [做减法, 承诺管理]