会自动更新的项目仪表盘

AI+Obsidian效率革命

会自动更新的项目仪表盘

AI + Obsidian 效率革命 · 场景三 · 第 13 篇

---

🎯 每周浪费 3 小时的「手动更新」陷阱

上一篇我给了你 5 套 Canvas 作战室模板。如果你已经搭好了，此刻你应该有一张清晰的项目地图——北极星、战略支柱、里程碑、依赖关系，一目了然。

但我猜你已经遇到了一个问题。

你的作战室需要手动更新。

每完成一个任务，你得打开里程碑笔记，手动勾选 checkbox。然后打开 Canvas，手动修改里程碑卡片的状态颜色。然后计算一下进度百分比，手动填上去。然后检查一下有没有逾期的里程碑，手动标红。然后算一下整体项目进度……

一个有 14 个里程碑、每个里程碑下面有 8-15 个任务的项目——每周的「状态更新」大概要花 2-3 小时。

2-3 小时，你在做数据搬运工，不是在管理项目。

我有一个学员，她管理一个课程开发项目，用了第 12 篇的课程模板搭了一个漂亮的作战室。但两周后她跟我说：

"作战室是好用的，但每周一的早上我需要花一整个上午更新所有里程碑的状态。到了第三周我开始偷懒，只更新最紧急的几个。到了第四周，Canvas 上的数据已经和实际情况脱节了。然后我就不想看它了。"

她的作战室在第四周「死了」。

死因不是作战室设计得不好，而是维护成本太高。

任何需要大量手动维护的系统都有同一个命运——刚建好时很兴奋，一个月后变成负担，两个月后被遗弃。

解决方案是什么？

让数据自己流动。

让任务完成时进度自动更新。让截止日期过了里程碑自动变红。让整体项目进度自动计算。让风险指标自动预警。

你唯一需要做的事是：完成任务时打个勾。其余一切——计算、汇总、预警、展示——全部自动化。

今天这篇文章，我教你把作战室从一张「需要手动维护的静态地图」升级为一个「自动驾驶的实时导航系统」。

核心技术栈只有两个：Dataview（Obsidian 的数据查询引擎）+ Templater（自动化脚本引擎）。不需要写代码基础——所有代码我都写好了，你复制粘贴就能用。

---

🧠 底层架构：数据怎么从任务流向仪表盘

在动手之前，先理解数据流的全局架构。

text

┌──────────────────────────────────────────────────────────────┐
│                                                              │
│         自动化仪表盘 · 数据流架构                             │
│                                                              │
│                                                              │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  📝 数据源层：你的日常操作                           │    │
│  │                                                     │    │
│  │  你做的唯一事情：在任务清单中打勾 ✅                 │    │
│  │  → 在里程碑笔记中完成一个 checkbox                  │    │
│  │  → 或在笔记的 frontmatter 中更新一个字段            │    │
│  │                                                     │    │
│  │  所有其他信息已经在笔记的元数据中：                  │    │
│  │  → 截止日期（deadline 字段）                        │    │
│  │  → 所属支柱（pillar 字段）                          │    │
│  │  → 负责人（owner 字段）                             │    │
│  │  → 依赖关系（dependencies 字段）                    │    │
│  │                                                     │    │
│  └──────────────────────┬──────────────────────────────┘    │
│                         ↓                                    │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  🔧 计算层：Dataview 自动查询和计算                  │    │
│  │                                                     │    │
│  │  Dataview 做什么：                                   │    │
│  │  → 自动统计每个里程碑的任务完成率                   │    │
│  │  → 自动判断里程碑是否逾期                           │    │
│  │  → 自动计算每个支柱的整体进度                       │    │
│  │  → 自动计算全项目进度                               │    │
│  │  → 自动识别阻塞和风险                               │    │
│  │                                                     │    │
│  │  关键：Dataview 是实时查询的——                       │    │
│  │  你打了一个勾 → 刷新页面 → 数据立刻更新             │    │
│  │  不需要"运行"任何东西                                │    │
│  │                                                     │    │
│  └──────────────────────┬──────────────────────────────┘    │
│                         ↓                                    │
│  ┌─────────────────────────────────────────────────────┐    │
│  │  📊 展示层：仪表盘笔记 + Canvas 嵌入                │    │
│  │                                                     │    │
│  │  仪表盘笔记：一个 Obsidian 笔记，                   │    │
│  │  里面全是 Dataview 查询代码，                        │    │
│  │  自动渲染为表格/列表/进度条                          │    │
│  │                                                     │    │
│  │  Canvas 嵌入：将仪表盘笔记嵌入 Canvas 作战室，      │    │
│  │  你打开作战室就能看到实时数据                        │    │
│  │                                                     │    │
│  └─────────────────────────────────────────────────────┘    │
│                                                              │
│  ⏱️ 整个流程的人工参与：                                    │
│  → 完成任务 → 打个勾 → 结束                                │
│  → 其余全自动                                               │
│  → 每周节省 2-3 小时的手动更新时间                          │
│                                                              │
└──────────────────────────────────────────────────────────────┘

---

🔧 基础设施：让数据"可被查询"

自动化仪表盘的前提是——你的笔记中的数据必须是"结构化的"，这样 Dataview 才能查询它。

里程碑笔记的标准化元数据

每个里程碑笔记的 frontmatter 必须包含以下字段：

Markdown

---
type: milestone
project: "AI+Obsidian课程"
pillar: 产品
milestone_id: M2
title: "前5篇内容完成"
status: in-progress
deadline: 2025-05-01
owner: "张三"
priority: high
dependencies: ["M1"]
blocks: ["M3", "M4"]
created: 2025-04-01
completed_date: 
tags: [milestone]
---

字段说明：

text

┌──────────────────┬───────────────────────────────────────────┐
│ 字段              │ 用途                                      │
├──────────────────┼───────────────────────────────────────────┤
│ type             │ 固定为 "milestone"，用于 Dataview 过滤    │
│ project          │ 所属项目名，支持多项目管理                │
│ pillar           │ 所属战略支柱（产品/增长/运营/技术）       │
│ milestone_id     │ 唯一编号（M1, M2, M3...）                │
│ status           │ 状态：not-started / in-progress /         │
│                  │        completed / blocked / overdue       │
│ deadline         │ 截止日期（YYYY-MM-DD 格式）               │
│ owner            │ 负责人                                    │
│ priority         │ 优先级：high / medium / low               │
│ dependencies     │ 依赖哪些里程碑（数组）                    │
│ blocks           │ 阻塞了哪些里程碑（数组）                  │
│ completed_date   │ 实际完成日期（完成后填入）                │
└──────────────────┴───────────────────────────────────────────┘

任务的标准化写法

在里程碑笔记的正文中，任务用标准的 Obsidian checkbox 写：

Markdown

## 任务清单
### 内容制作
- [x] 第 01 篇初稿完成
- [x] 第 01 篇审核通过
- [x] 第 02 篇初稿完成
- [ ] 第 02 篇审核通过
- [ ] 第 03 篇初稿完成
- [ ] 第 03 篇审核通过
### 配套资源
- [x] Prompt 包整理
- [ ] Obsidian 模板制作
- [ ] 自动化脚本调试

关键原则：你只需要打勾。Dataview 会自动读取 checkbox 的完成状态并计算进度。

---

📊 核心仪表盘：七个自动化面板

以下是我实战中最有价值的七个仪表盘面板。每个面板都是一段 Dataview 代码——复制到一个 Obsidian 笔记里就能用。

面板 1：全项目进度总览

这是仪表盘的「第一屏」——打开就能看到项目的整体状态。

Markdown

## 📊 项目进度总览
### 里程碑状态分布
```dataview
TABLE 
  length(filter(rows, (r) => r.status = "completed")) as "✅ 完成",
  length(filter(rows, (r) => r.status = "in-progress")) as "🟡 进行中",
  length(filter(rows, (r) => r.status = "not-started")) as "⬜ 未开始",
  length(filter(rows, (r) => r.status = "blocked")) as "🔴 阻塞",
  length(rows) as "总计",
  round(length(filter(rows, (r) => r.status = "completed")) / length(rows) * 100) + "%" as "完成率"
FROM ""
WHERE type = "milestone" AND project = "AI+Obsidian课程"
GROUP BY project

各支柱进度

dataview

TABLE 
  length(filter(rows, (r) => r.status = "completed")) + "/" + length(rows) as "进度",
  round(length(filter(rows, (r) => r.status = "completed")) / length(rows) * 100) + "%" as "完成率",
  min(filter(rows, (r) => r.status != "completed").deadline) as "最近截止"
FROM ""
WHERE type = "milestone" AND project = "AI+Obsidian课程"
GROUP BY pillar
SORT pillar ASC

面板 2：逾期预警

这是仪表盘中最重要的面板——它自动识别所有已经逾期或即将逾期的里程碑。

## 🚨 逾期预警
### 已逾期（截止日期已过但未完成）
```dataview
TABLE 
  title as "里程碑",
  pillar as "支柱",
  deadline as "截止日期",
  owner as "负责人",
  (date(today) - deadline).days + " 天" as "逾期天数"
FROM ""
WHERE type = "milestone" 
  AND project = "AI+Obsidian课程"
  AND status != "completed"
  AND deadline < date(today)
SORT deadline ASC

未来 7 天到期（即将逾期预警）

dataview

TABLE 
  title as "里程碑",
  pillar as "支柱",
  deadline as "截止日期",
  owner as "负责人",
  (deadline - date(today)).days + " 天后" as "剩余时间"
FROM ""
WHERE type = "milestone" 
  AND project = "AI+Obsidian课程"
  AND status != "completed"
  AND deadline >= date(today)
  AND deadline <= date(today) + dur(7 days)
SORT deadline ASC

[!warning] 自动预警规则 🔴 已逾期 → 立即处理或重新评估截止日期 🟡 7 天内到期 → 确认是否能按时完成，提前沟通风险

面板 3：任务级进度追踪

这个面板深入到每个里程碑内部，自动计算任务完成率。

## ✅ 任务进度（按里程碑）
```dataview
TABLE 
  title as "里程碑",
  pillar as "支柱",
  status as "状态",
  length(filter(file.tasks, (t) => t.completed)) + "/" + length(file.tasks) as "任务进度",
  round(length(filter(file.tasks, (t) => t.completed)) / length(file.tasks) * 100) + "%" as "完成率",
  deadline as "截止日期"
FROM ""
WHERE type = "milestone" AND project = "AI+Obsidian课程"
SORT deadline ASC

注意这个面板的魔力：file.tasks 会自动读取笔记中所有的 checkbox，t.completed 会自动判断哪些被勾选了。你只需要在笔记里打勾——进度数字会自动变化。

面板 4：负责人工作负载

当你有一个小团队时，这个面板告诉你每个人的工作量是否均衡。

## 👥 团队工作负载
```dataview
TABLE 
  length(filter(rows, (r) => r.status = "in-progress")) as "进行中",
  length(filter(rows, (r) => r.status = "not-started")) as "待开始",
  length(filter(rows, (r) => r.status = "blocked")) as "被阻塞",
  min(filter(rows, (r) => r.status != "completed").deadline) as "最近截止"
FROM ""
WHERE type = "milestone" AND project = "AI+Obsidian课程"
GROUP BY owner
SORT length(filter(rows, (r) => r.status = "in-progress")) DESC

[!tip] 负载均衡检查 如果某人的"进行中"里程碑 > 3 个 → 可能过载 如果某人的"被阻塞" > 0 → 需要帮他解除阻塞

面板 5：依赖链健康度

这个面板自动检测：有没有里程碑已经完成了，但它下游的里程碑还没有启动？（如果有，说明有人忘了"解锁"下一步。）

## 🔗 依赖链检查
### 可以启动但尚未启动的里程碑
（所有依赖都已完成，但自身状态仍为 not-started）
```dataviewjs
const milestones = dv.pages()
  .where(p => p.type === "milestone" && p.project === "AI+Obsidian课程");
const completedIds = milestones
  .where(p => p.status === "completed")
  .map(p => p.milestone_id);
const unblocked = milestones
  .where(p => {
    if (p.status !== "not-started") return false;
    if (!p.dependencies || p.dependencies.length === 0) return true;
    return p.dependencies.every(dep => completedIds.includes(dep));
  });
if (unblocked.length > 0) {
  dv.table(
    ["里程碑", "支柱", "负责人", "截止日期"],
    unblocked.map(p => [p.title, p.pillar, p.owner, p.deadline])
  );
} else {
  dv.paragraph("✅ 没有被遗漏的可启动里程碑");
}

[!info] 这个面板的价值 它自动检测"本应该已经开始但还没人动的工作"。 这是最容易被遗漏的项目管理问题—— 前置任务完成了，但没人通知下游负责人。 有了这个面板，遗漏会自动浮现。

面板 6：时间线可视化

用 DataviewJS 生成一个简易甘特图——在纯文本环境中已经足够好用。

## 📅 时间线
```dataviewjs
const milestones = dv.pages()
  .where(p => p.type === "milestone" && p.project === "AI+Obsidian课程")
  .sort(p => p.deadline, "asc");
const today = dv.date("today");
const statusIcon = {
  "completed": "✅",
  "in-progress": "🟡",
  "not-started": "⬜",
  "blocked": "🔴",
  "overdue": "🚨"
};
let output = "| 里程碑 | 支柱 | 截止日期 | 状态 | 距今 |\n";
output += "|--------|------|---------|------|------|\n";
for (const m of milestones) {
  const deadline = dv.date(m.deadline);
  const diff = Math.round((deadline - today) / (1000*60*60*24));

  let status = m.status;
  if (status !== "completed" && diff < 0) status = "overdue";

  const icon = statusIcon[status] || "❓";
  const diffStr = diff > 0 ? `${diff}天后` : diff === 0 ? "今天" : `逾期${-diff}天`;

  output += `| ${icon} ${m.title} | ${m.pillar} | ${m.deadline} | ${icon} | ${diffStr} |\n`;
}
dv.paragraph(output);

📍 今天：```dataview = date(today)

面板 7：项目健康度综合评分

这是仪表盘的「终极面板」——用一个综合评分告诉你项目是否健康。

## 🏥 项目健康度
```dataviewjs
const milestones = dv.pages()
  .where(p => p.type === "milestone" && p.project === "AI+Obsidian课程");
const total = milestones.length;
const completed = milestones.where(p => p.status === "completed").length;
const today = dv.date("today");
// 指标 1：完成率
const completionRate = total > 0 ? completed / total : 0;
// 指标 2：逾期率
const overdue = milestones
  .where(p => p.status !== "completed" && dv.date(p.deadline) < today).length;
const overdueRate = total > 0 ? overdue / total : 0;
// 指标 3：阻塞率
const blocked = milestones.where(p => p.status === "blocked").length;
const blockedRate = total > 0 ? blocked / total : 0;
// 综合健康度评分（0-100）
const healthScore = Math.round(
  (completionRate * 40) + 
  ((1 - overdueRate) * 35) + 
  ((1 - blockedRate) * 25)
) * 100 / 100;
// 健康等级
let grade, emoji, advice;
if (healthScore >= 80) { grade = "A"; emoji = "🟢"; advice = "项目健康运转，保持节奏"; }
else if (healthScore >= 60) { grade = "B"; emoji = "🟡"; advice = "有一些问题需要关注，检查逾期项"; }
else if (healthScore >= 40) { grade = "C"; emoji = "🟠"; advice = "项目出现明显问题，需要立即干预"; }
else { grade = "D"; emoji = "🔴"; advice = "项目处于危险状态，建议召开紧急会议"; }
dv.paragraph(`## ${emoji} 健康度评分：${healthScore} / 100（${grade} 级）`);
dv.paragraph(`**诊断建议**：${advice}`);
dv.paragraph(`---`);
dv.paragraph(`| 指标 | 数值 | 权重 |`);
dv.paragraph(`|------|------|------|`);
dv.paragraph(`| 完成率 | ${Math.round(completionRate*100)}% (${completed}/${total}) | 40% |`);
dv.paragraph(`| 逾期率 | ${Math.round(overdueRate*100)}% (${overdue}个逾期) | 35% |`);
dv.paragraph(`| 阻塞率 | ${Math.round(blockedRate*100)}% (${blocked}个阻塞) | 25% |`);

**健康度评分的价值**：

你不需要逐个检查 14 个里程碑的状态。 你只需要看一个数字——

🟢 85 分 → "一切正常，继续做手上的事" 🟡 62 分 → "有些事情不对，让我检查一下" 🔴 35 分 → "出大事了，现在就处理"

一个数字代替了 30 分钟的手动状态检查。 这就是自动化仪表盘的核心价值。

🖥️ 将仪表盘嵌入 Canvas 作战室

七个面板做好后，下一步是把它嵌入你的 Canvas 作战室，让你打开作战室就能看到实时数据。

方法：Canvas 嵌入笔记

Step 1：创建仪表盘笔记 → 新建笔记：📊 Dashboard/[项目名]-仪表盘.md → 将上面七个面板的代码全部放进这个笔记 → 保存
Step 2：在 Canvas 中嵌入 → 打开你的 Canvas 作战室 → 在画布的合适位置（推荐顶部或右侧） → 拖拽仪表盘笔记到 Canvas 上 → 或者：在 Canvas 中输入 [[ 搜索笔记名嵌入
Step 3：调整大小和位置 → 在 Canvas 中调整嵌入笔记的大小 → 建议宽度占画布的 30-40% → 放在作战室的右侧或顶部
效果： → 打开 Canvas → 左侧是里程碑地图 → 右侧是实时仪表盘 → 一个界面看到"该做什么"+"做得怎么样" → 不需要在两个笔记之间切换

仪表盘的布局建议

┌──────────────────────────────────────────────────────────────┐ │ │ │ Canvas 作战室 + 嵌入仪表盘的推荐布局 │ │ │ │ ┌──────────────────────────┬─────────────────────────┐ │ │ │ │ │ │ │ │ 🎯 北极星 │ 📊 仪表盘 │ │ │ │ │ │ │ │ │ 🏛️ 战略支柱 │ 面板1: 进度总览 │ │ │ │ │ 面板2: 逾期预警 │ │ │ │ │ 面板7: 健康度评分 │ │ │ │ 🧱 里程碑地图 │ │ │ │ │ (占画布 60% 面积) │ (占画布 35% 面积) │ │ │ │ │ │ │ │ │ M1──→M2──→M3──→M4 │ ───────────── │ │ │ │ │ │ ↑ │ │ │ │ │ ↓ ↓ │ │ 面板3: 任务进度 │ │ │ │ M5──→M6──→M7──→M8 │ 面板5: 依赖链检查 │ │ │ │ │ 面板6: 时间线 │ │ │ │ │ │ │ │ ├──────────────────────────┤ │ │ │ │ ⚠️ 风险看板 + 决策日志 │ 面板4: 负责人负载 │ │ │ │ (画布底部) │ │ │ │ └──────────────────────────┴─────────────────────────┘ │ │ │ │ 左侧 = 战略视图（你的计划是什么） │ │ 右侧 = 数据视图（你的计划执行得怎么样） │ │ 一个画布 = 计划 + 监控 = 完整的项目管理闭环 │ │ │ └──────────────────────────────────────────────────────────────┘

---

⚡ 进阶自动化：让"状态"也自动更新

基础仪表盘已经能自动计算进度了。但还有一个手动环节——你需要在里程碑笔记的 frontmatter 中手动更新 status 字段。

以下用 Templater 脚本来自动化这一步。

自动状态更新脚本

<%*
// ============================================
// ⚡ 里程碑状态自动更新器
// ============================================
// 功能：根据任务完成率和截止日期自动更新状态
const file = tp.file;
const content = await app.vault.read(tp.file.find_tfile(file.path));
const cache = app.metadataCache.getFileCache(tp.file.find_tfile(file.path));
const metadata = cache?.frontmatter;
if (metadata?.type !== "milestone") {
new Notice("⚠️ 这不是里程碑笔记");
return;
}
// 计算任务完成率
const tasks = cache?.listItems?.filter(item => item.task !== undefined) || [];
const completedTasks = tasks.filter(item => item.task === "x");
const totalTasks = tasks.length;
const completionRate = totalTasks > 0 ? completedTasks.length / totalTasks : 0;
// 判断是否逾期
const today = newDate();
const deadline = metadata.deadline ? newDate(metadata.deadline) : null;
const isOverdue = deadline && today > deadline;
// 自动判断新状态
let newStatus;
if (completionRate === 1) {
    newStatus = "completed";
} elseif (completionRate === 0 && !isOverdue) {
    newStatus = "not-started";
} elseif (isOverdue && completionRate < 1) {
    newStatus = "overdue";
} elseif (completionRate > 0 && completionRate < 1) {
    newStatus = "in-progress";
}
// 检查是否有依赖未完成（阻塞检测）
if (metadata.dependencies && metadata.dependencies.length > 0) {
const allMilestones = app.vault.getMarkdownFiles()
        .map(f => app.metadataCache.getFileCache(f)?.frontmatter)
        .filter(fm => fm?.type === "milestone" && fm?.project === metadata.project);

const depsMet = metadata.dependencies.every(depId => {
const dep = allMilestones.find(m => m.milestone_id === depId);
return dep && dep.status === "completed";
    });

if (!depsMet && newStatus === "not-started") {
        newStatus = "blocked";
    }
}
// 更新 frontmatter
const oldStatus = metadata.status;
if (newStatus && newStatus !== oldStatus) {
const updatedContent = content.replace(
/status: .+/,
`status: ${newStatus}`
    );

// 如果刚完成，记录完成日期
if (newStatus === "completed" && !metadata.completed_date) {
const completedContent = updatedContent.replace(
/completed_date: */,
`completed_date: ${tp.date.now("YYYY-MM-DD")}`
        );
await app.vault.modify(tp.file.find_tfile(file.path), completedContent);
    } else {
await app.vault.modify(tp.file.find_tfile(file.path), updatedContent);
    }

new Notice(`状态更新：${oldStatus} → ${newStatus}`);
} else {
new Notice(`状态未变化：${oldStatus}`);
}
-%>

使用方式

text

方式 A：手动触发（推荐新手）
→ 打开一个里程碑笔记
→ 完成任务后打勾
→ 按 Alt+E → 选择"状态自动更新"模板
→ 状态自动计算并更新
方式 B：批量更新（推荐每周一次）
→ 创建一个"批量更新"脚本
→ 遍历所有里程碑笔记
→ 逐个运行状态更新逻辑
→ 一键更新全项目状态

批量状态更新脚本

JavaScript

<%*
// ============================================
// ⚡ 全项目里程碑状态批量更新
// ============================================
const files = app.vault.getMarkdownFiles();
let updated = 0;
let errors = 0;
for (const file of files) {
    const cache = app.metadataCache.getFileCache(file);
    const fm = cache?.frontmatter;
    if (fm?.type !== "milestone") continue;
    try {
        const content = await app.vault.read(file);
        const tasks = cache?.listItems?.filter(item => item.task !== undefined) || [];
        const completedTasks = tasks.filter(item => item.task === "x");
        const rate = tasks.length > 0 ? completedTasks.length / tasks.length : 0;
        const today = new Date();
        const deadline = fm.deadline ? new Date(fm.deadline) : null;
        const isOverdue = deadline && today > deadline;
        let newStatus;
        if (rate === 1) newStatus = "completed";
        else if (rate === 0) newStatus = "not-started";
        else if (isOverdue) newStatus = "overdue";
        else newStatus = "in-progress";
        if (newStatus !== fm.status) {
            let updatedContent = content.replace(
                /status: .+/, 
                `status: ${newStatus}`
            );
            if (newStatus === "completed" && !fm.completed_date) {
                updatedContent = updatedContent.replace(
                    /completed_date: */,
                    `completed_date: ${tp.date.now("YYYY-MM-DD")}`
                );
            }
            await app.vault.modify(file, updatedContent);
            updated++;
        }
    } catch(e) {
        errors++;
    }
}
new Notice(`✅ 批量更新完成：${updated} 个里程碑状态已更新${errors > 0 ? `，${errors} 个错误` : ""}`);
-%>

text

使用方式：
→ 每周一早上
→ 打开任意笔记
→ 运行"批量状态更新"模板
→ 所有里程碑状态自动刷新
→ 然后打开 Canvas → 仪表盘数据已是最新
→ ⏱️ 全过程：< 30 秒
→ 替代了之前每周 2-3 小时的手动更新

---

🤖 AI 增强：智能项目诊断

基础自动化解决了"数据搬运"问题。AI 可以进一步解决"数据解读"问题——不只是告诉你"进度是 60%"，而是告诉你"60% 意味着什么、有什么风险、应该怎么调整"。

AI 周度项目诊断 Prompt

Markdown

# Prompt：AI 项目诊断师
你是一位资深项目管理顾问。
以下是一个项目的当前状态数据。
请做一次全面诊断。
## 项目基本信息
- 项目名：[项目名]
- 总工期：[起止日期]
- 当前日期：[今天]
- 时间消耗比例：[已过天数/总天数]%
## 里程碑状态
[粘贴面板 1 的输出——各支柱进度]
[粘贴面板 2 的输出——逾期清单]
[粘贴面板 3 的输出——任务级进度]
[粘贴面板 5 的输出——依赖链检查]
[粘贴面板 7 的输出——健康度评分]
## 请诊断
### 1. 一句话诊断
用一句话描述项目当前的核心状态。
格式："项目 [健康/有风险/危险]，核心问题是 [X]"
### 2. 进度 vs 时间分析
时间消耗了 X%，进度完成了 Y%。
这意味着什么？
→ 如果 Y > X → 超前进度（好消息但检查是否牺牲了质量）
→ 如果 Y ≈ X → 正常节奏
→ 如果 Y < X → 落后进度（需要分析原因）
### 3. 关键路径风险
基于逾期数据和依赖关系，
关键路径上是否有风险？
如果有，哪个里程碑是"瓶颈"——
即它的延迟会导致最大的连锁反应？
### 4. 本周 Top 3 建议
基于当前数据，本周最应该做的三件事是什么？
按优先级排序。
### 5. 预测
如果保持当前节奏，项目能按时完成吗？
如果不能，预计延期多少天？
提出 2 个可能的补救方案。

使用方式

text

每周一的 30 分钟周度审查流程升级版：
⏱️ 0:00-0:01 | 运行批量状态更新脚本（自动）
⏱️ 0:01-0:03 | 打开 Canvas → 看仪表盘（扫一眼健康度评分）
⏱️ 0:03-0:08 | 复制仪表盘关键数据 → 输入 AI 诊断 Prompt
⏱️ 0:08-0:15 | 阅读 AI 诊断报告
⏱️ 0:15-0:25 | 基于 AI 建议调整本周优先级
⏱️ 0:25-0:30 | 在 Canvas 决策日志中记录本周调整及理由
→ 从"手动更新 + 手动分析"的 2-3 小时
→ 压缩到"自动更新 + AI 分析"的 30 分钟
→ 而且分析质量更高（因为 AI 看到了全局数据）

---

🧩 高阶技巧：条件格式化——让数据自己"说话"

数字本身不够直观。人类视觉系统对颜色和形状的敏感度远高于数字。以下技巧让仪表盘的数据用视觉语言"说话"。

技巧 1：进度条可视化

Markdown

### 各里程碑进度条
```dataviewjs
const milestones = dv.pages()
  .where(p => p.type === "milestone" && p.project === "AI+Obsidian课程")
  .sort(p => p.deadline, "asc");
for (const m of milestones) {
  const tasks = m.file.tasks;
  const total = tasks.length;
  const done = tasks.where(t => t.completed).length;
  const pct = total > 0 ? Math.round(done / total * 100) : 0;
  const filled = Math.round(pct / 5);
  const empty = 20 - filled;
  const bar = "█".repeat(filled) + "░".repeat(empty);
  const statusEmoji = m.status === "completed" ? "✅" : 
                       m.status === "overdue" ? "🚨" :
                       m.status === "blocked" ? "🔴" :
                       m.status === "in-progress" ? "🟡" : "⬜";
  dv.paragraph(`${statusEmoji} **${m.title}** ${bar} ${pct}% (${done}/${total})`);
}

效果示例：

✅ 课程大纲定稿 ████████████████████ 100% (8/8) 
🟡 前5篇内容完成 ████████████░░░░░░░░ 60% (12/20) 
⬜ AI练习系统上线 ░░░░░░░░░░░░░░░░░░░░ 0% (0/10) 
🚨 内测版完成 ██████░░░░░░░░░░░░░░ 30% (3/10) ← 逾期！ 
⬜ 正式上线 ░░░░░░░░░░░░░░░░░░░░ 0% (0/15)

一眼就能看到：第四个里程碑逾期了（🚨），而且进度只有 30%。这在一个数字表格中需要逐行扫描才能发现，但在进度条可视化中一秒就看到了。

技巧 2：热力图——本周活跃度

### 📅 本周活跃度热力图
```dataviewjs
const today = dv.date("today");
const weekStart = dv.date(today - dv.duration("6 days"));
const days = ["一","二","三","四","五","六","日"];
let output = "| ";
for (let i = 0; i < 7; i++) {
  const d = dv.date(weekStart.plus(dv.duration(`${i} days`)));
  output += `周${days[i]} | `;
}
output += "\n|";
for (let i = 0; i < 7; i++) output += "------|";
output += "\n|";
for (let i = 0; i < 7; i++) {
  const d = dv.date(weekStart.plus(dv.duration(`${i} days`)));
  const tasks = dv.pages()
    .where(p => p.type === "milestone" && p.project === "AI+Obsidian课程")
    .file.tasks
    .where(t => t.completed && t.completion && 
           dv.date(t.completion).equals(d));

  const count = tasks.length;
  const heat = count >= 5 ? "🟢🟢🟢" : 
               count >= 3 ? "🟢🟢" :
               count >= 1 ? "🟢" : "⚪";

  output += ` ${heat} ${count} |`;
}
dv.paragraph(output);

技巧 3：里程碑依赖关系可视化

### 🔗 依赖关系图（ASCII 版）
```dataviewjs
const milestones = dv.pages()
  .where(p => p.type === "milestone" && p.project === "AI+Obsidian课程")
  .sort(p => p.milestone_id, "asc");
let output = "```\n";
for (const m of milestones) {
  const icon = m.status === "completed" ? "✅" :
               m.status === "in-progress" ? "🟡" :
               m.status === "blocked" ? "🔴" :
               m.status === "overdue" ? "🚨" : "⬜";

  let line = `${icon} ${m.milestone_id}: ${m.title}`;

  if (m.blocks && m.blocks.length > 0) {
    line += ` ──→ 阻塞 [${m.blocks.join(", ")}]`;
  }

  if (m.dependencies && m.dependencies.length > 0) {
    line += ` ← 依赖 [${m.dependencies.join(", ")}]`;
  }

  output += line + "\n";
}
output += "```";
dv.paragraph(output);

⚠️ 常见问题与避坑指南

问题 1：Dataview 查询不实时更新

症状：你打了一个勾，但仪表盘数字没变。
原因：Dataview 的缓存机制。
解决： → 方法 A：切换到其他笔记再切换回来（触发刷新） → 方法 B：Ctrl+P → 输入 "Dataview: Force refresh" → 方法 C：在 Dataview 设置中降低缓存时间
最佳实践： → 不要期望"实时到毫秒级" → Dataview 的刷新延迟通常在 1-5 秒 → 对于项目管理来说完全够用

问题 2：里程碑太多导致仪表盘很长

解决方案：分层仪表盘
顶层仪表盘（嵌入 Canvas）： → 只包含面板 1（总览）+ 面板 2（预警）+ 面板 7（健康度） → 最多占一屏
详细仪表盘（独立笔记，需要时打开）： → 包含全部 7 个面板 → 用于周度审查的深度分析
→ 日常看顶层（5 秒扫一眼） → 周一看详细（30 分钟深入分析）

问题 3：多项目管理

如果你同时管理多个项目：
方案 A：每个项目一个 Canvas + 一个仪表盘 → 适合：项目之间独立 → 在仪表盘的 Dataview 查询中用 project 字段过滤
方案 B：一个总控仪表盘 + 多个项目仪表盘 → 总控仪表盘只显示每个项目的健康度评分 → 点进去看详细
总控仪表盘示例：
dataview
```
TABLE
  project as "项目",
  length(filter(rows, (r) => r.status = "completed")) + "/" + length(rows) as "进度",
  length(filter(rows, (r) => r.status = "overdue")) as "逾期数",
  min(filter(rows, (r) => r.status != "completed").deadline) as "最近截止"
FROM ""
WHERE type = "milestone"
GROUP BY project
SORT project ASC

问题 4：非技术人员看不懂 Dataview 代码

仪表盘笔记在"阅读模式"下不显示代码—— 只显示渲染后的表格和数字。
所以： → 编辑模式 = 你维护代码的界面 → 阅读模式 = 团队成员看到的界面 → Canvas 中嵌入的是"阅读模式"的渲染结果 → 非技术人员只需要看数字和图表 → 他们不需要知道 Dataview 的存在

---

📅 仪表盘驱动的项目管理节奏

有了自动化仪表盘后，你的项目管理节奏变成了这样：

┌──────────────────────────────────────────────────────────────┐ │ │ │ 仪表盘驱动的项目管理节奏 │ │ │ │ 📅 每天（2 分钟） │ │ ────────────────── │ │ → 打开 Canvas → 看健康度评分（5 秒） │ │ → 🟢 80+ → 继续做手上的事 │ │ → 🟡 60-79 → 快速看一眼逾期预警 │ │ → 🔴 <60 → 立即检查详细仪表盘 │ │ → 完成今天的任务 → 在笔记中打勾 → 结束 │ │ │ │ 📅 每周一（30 分钟） │ │ ────────────────── │ │ → 运行批量状态更新脚本（30 秒） │ │ → 复制仪表盘数据 → 运行 AI 诊断 Prompt（5 分钟） │ │ → 阅读 AI 诊断报告（5 分钟） │ │ → 根据诊断调整本周优先级（10 分钟） │ │ → 在决策日志记录调整及理由（5 分钟） │ │ → 更新 Canvas 上需要手动更新的信息 │ │ （如风险看板、新的决策）（5 分钟） │ │ │ │ 📅 每个里程碑完成时（15 分钟） │ │ ────────────────── │ │ → 确认所有任务已勾选 │ │ → 运行状态更新（自动变为 completed） │ │ → 检查下游里程碑是否自动解锁 │ │ → 做一次快速复盘（3-5 条） │ │ → 在 Canvas 上将里程碑卡片标绿 ✅ │ │ │ │ 📅 每月底（1 小时） │ │ ────────────────── │ │ → 做一次完整的 AI 项目诊断 │ │ → 回顾北极星是否需要调整 │ │ → 检查战略假设是否仍然成立 │ │ → Canvas 快照存档 │ │ → 做一次仪表盘本身的优化 │ │ （哪些指标没用？需要加什么指标？） │ │ │ │ ────────────────────────────────────────────────────────── │ │ │ │ 时间对比： │ │ 手动管理：每周 3-4 小时 + 大量心理负担 │ │ 自动化管理：每周 30 分钟 + 零心理负担 │ │ 节省：每周 3+ 小时 × 52 周 = 每年 150+ 小时 │ │ 这 150 小时可以用来做真正产出价值的事情 │ │ │ └──────────────────────────────────────────────────────────────┘
text

---

🚀 你的行动清单

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 今天（30 分钟） ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
□ 确保你的里程碑笔记有标准化的 frontmatter → 至少包含：type, project, pillar, status, deadline □ 创建仪表盘笔记 → 先放入面板 1（总览）和面板 7（健康度） → 这两个面板就够日常使用了 □ 将仪表盘笔记嵌入 Canvas 作战室
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 本周 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
□ 添加面板 2（逾期预警）和面板 3（任务进度） □ 尝试进度条可视化（技巧 1） □ 配置状态自动更新脚本 □ 运行一次批量状态更新 □ 做第一次 AI 项目诊断
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 本月 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
□ 补全全部 7 个面板 □ 固化每周一 30 分钟的审查流程 □ 根据使用体验调整面板内容 □ 体验"打勾→数据自动流动→决策自动浮现"的闭环
□ 一个月后你会发现： → 你不再"管理"项目了 → 项目在"自己管理自己" → 你只需要做两件事：完成任务 + 做决策 → 所有中间的"数据搬运"已经消失了
text

---

✍️ 写在最后

回到开头那个"第四周死掉的作战室"。

那个学员后来用了这套自动化仪表盘。两个月后她给我发了一条消息：

"我现在每周一早上打开 Canvas，第一件事看健康度评分。上周是 78 分，这周是 83 分。我甚至没有刻意去'管理'项目——我只是每天完成任务后打个勾。但数字自己在往上走。这种感觉太好了。"

"数字自己在往上走"——这句话就是自动化仪表盘的全部意义。

当你不需要花精力"维护系统"时，你的全部精力都可以投入到"推进项目"上。当系统自己追踪进度时，你的认知资源被释放出来做真正需要人类智慧的事情——思考策略、做创造性决策、解决复杂问题。

这是一个更深层的原则——

好的系统是隐形的。

你感受不到它的存在，但它在背后默默运转。就像心脏——你不需要"记得跳动"，它自己跳。你的项目管理系统也应该如此。

你只需要做两件事：

1. 完成任务（打勾）
2. 做决策（看数据后判断）

中间的一切——计算、汇总、比较、预警、可视化——让机器做。

从今天开始，让你的作战室活起来。

让数据自己流动。

让问题自己浮现。

让你的注意力回到它应该在的地方——创造价值。

---

下一篇预告：《年入千万知识付费项目复盘》——理论讲完了，下一篇来点真的。我将用 Canvas 作战室完整复盘一个从 0 到年营收千万的知识付费项目——每一个战略决策、每一次踩坑、每一个关键转折点。你会看到五层架构在真实商业项目中是怎么运转的，以及哪些理论在实战中"不好使"需要调整。

---

💬 你的仪表盘搭好了吗？健康度评分是多少？评论区晒出你的第一个健康度得分——不管多低都行，重要的是你开始追踪了。

🔄 如果你身边有人每周花好几小时"更新项目进度表"，把这篇转发给他——他需要的不是更多时间，而是一个自动化系统。

获取资源包完整文件，请点击了解详情 →