认知动力学矩阵系统（CDMS）设计文档

前言：设计意图

CDMS 要回答一个核心问题：认知劳动如何被记录、量化、追踪和分析？

传统的任务管理工具把工作视为"挂在任务下的操作"------你有一个任务，然后你在它下面做事。但这个假设在认知密集的工作中不成立：一次调研可能同时推进了多个任务的进展，一次调试可能澄清了上层架构。劳动不是任务的附属品。

CDMS 的核心设计思想：劳动记录与任务网络分离。 任务是任务（计划单元），劳动是劳动（记录单元）。劳动是推动任务向前的动力------每次劳动产生的 Δ S ⃗ \Delta\vec{S} ΔS 作用在受益节点上，推动该节点及其祖先的状态更新。

一、劳动记录：单纯任务

1.1 设计问题

如何记录一次认知劳动？

最简单的答案是：记下来做了什么、花了多少时间。但这样不够------我们需要知道这次劳动产生了什么价值。在认知工作中，一次劳动可能同时推进多个方面的进展：

执行推进（写代码、做实验）→ 提升 D（Done）
学习积累（读文档、看论文）→ 提升 L（Learnt）
思考收敛（设计方案、分析问题）→ 提升 T（Thought）

1.2 投入与产出

每次劳动记录两个部分：

投入向量 C ⃗ \vec{C} C ：花了多少时间/精力在什么类型的劳动上。

C ⃗ = $c D c L c T$ \vec{C} = \begin{bmatrix} c_D \\ c_L \\ c_T \end{bmatrix} C = cDcLcT

由于人一次只能专注于一种模式， C ⃗ \vec{C} C 通常只有一个分量非零（单热向量）：

编码 3 小时 → C ⃗ = $3 , 0 , 0$ T \vec{C} = $3, 0, 0$ ^T C = $3,0,0$ T
读论文 1 小时 → C ⃗ = $0 , 1 , 0$ T \vec{C} = $0, 1, 0$ ^T C = $0,1,0$ T
设计方案 2 小时 → C ⃗ = $0 , 0 , 2$ T \vec{C} = $0, 0, 2$ ^T C = $0,0,2$ T

产出评估 Δ S ⃗ \Delta\vec{S} ΔS ：这次劳动推进了多少 D、L、T。

Δ S ⃗ = $Δ D Δ L Δ T Δ M$ \Delta\vec{S} = \begin{bmatrix} \Delta D \\ \Delta L \\ \Delta T \\ \Delta M \end{bmatrix} ΔS = ΔDΔLΔTΔM

其中 Δ M \Delta M ΔM 是意义/重要性的变化（可选字段，默认 0）------通过这次劳动，你对某个任务的重要性认知发生了改变。M 的变化是劳动的副产品，不是第四种劳动类型。

1.3 独立劳动记录

设计决策：单纯任务不绑定到任何任务节点。

一次劳动就是一次劳动。它不需要"挂靠"在某个任务下面。劳动结束后，用户指定这次劳动的主要受益节点（可以是 DAG 中的任意节点）。这种分离带来了两个关键优势：

同一份劳动可以影响多个节点------劳动本身是独立的，影响是评估出来的
评估与执行解耦------做的时候不需要想"这是哪个任务的"，做完再评估收益

1.4 主要受益节点与额外影响

劳动产出评估分为两个层次：

主要受益节点（必填） ：用户指定此次劳动主要推进了哪个节点，对该节点评估 Δ S ⃗ \Delta\vec{S} ΔS 。

额外影响节点（可选） ：当自动传播（见第四章）不足以解释此次劳动的全部产出时，用户可为其他节点手动指定独立的 Δ S ⃗ \Delta\vec{S} ΔS 。

复制代码

劳动记录示例：
  "技术调研：OAuth 2.1 的实现方案"
  投入: C = [0, 3, 1]^T（3h 学习 + 1h 思考）
  
  主要受益节点：OAuth 集成
  ΔS = [ΔD=0, ΔL=0.5, ΔT=0.3, ΔM=0]
  → 自动传播到 OAuth 集成 的所有祖先节点
  
  额外影响节点（可选）：
  - 安全审计: [ΔL=0.2, ΔT=0.1]
  （因为发现这个方案也简化了安全审计的工作量）

"只评估一次"在这里的含义 ：用户只做一次劳动记录，填一次主要受益节点的 Δ S ⃗ \Delta\vec{S} ΔS 。额外影响节点只在自动传播不够时补充，不是常规操作。

二、任务网络：DAG 的构建

2.1 设计问题

如何组织任务之间的关系？

传统做法是树结构（一个父节点，多个子节点）。但认知工作往往有更复杂的依赖关系------一个子任务可能同时服务于多个上级目标。因此系统使用 有向无环图（DAG） 而不是树。

2.2 节点

节点代表一个"可被追踪的认知标的"------它可以是一个项目、一个模块、一个功能点、一个研究问题。每个节点持有状态向量：

S ⃗ = $D L T M$ ∈ $0 , 1$ 4 \vec{S} = \begin{bmatrix} D \\ L \\ T \\ M \end{bmatrix} \in $0, 1$ ^4 S = DLTM ∈ $0,1$ 4

D（Done）：执行完成度------实际推进了多少
L（Learnt）：学习内化度------知识获取了多少
T（Thought）：思考收敛度------推演决策完成了多少
M（Meaning） ：该节点对其父节点的重要性。在全拓扑意义矩阵中， M i j M_{ij} Mij 可定义于任意节点对。

节点的状态来自一次次的单纯劳动对其产生的贡献（直接作为受益节点，或通过 M 加权自动传播）。节点不"执行"劳动，它只是积累劳动对它的影响。

可选属性：截止日期与工作量预估

节点可附带如下规划属性（非必须，设了才有 deadline 相关计算）：

字段	类型	说明
`deadline`	Date	截止日期（可选）
`estimatedWorkload`	number (h)	预估总工作量，单位为小时（有 deadline 时必填）

deadline 与 estimatedWorkload 共同引入了一个绝对量纲------D/L/T 只是完成比例，有了预估工作量才能知道"还剩多少绝对工作量"。由此推导出紧急度：

W r e m a i n i n g = W ^ ⋅ ( 1 − min ⁡ ( D , L , T ) ) W_{remaining} = \hat{W} \cdot (1 - \min(D, L, T)) Wremaining=W^⋅(1−min(D,L,T))

u r g e n c y = W r e m a i n i n g max ⁡ ( 1 , t d e a d l i n e − t t o d a y ) urgency = \frac{W_{remaining}}{\max(1,\ t_{deadline} - t_{today})} urgency=max(1, tdeadline−ttoday)Wremaining

W r e m a i n i n g W_{remaining} Wremaining：剩余工作量估值的绝对小时数
u r g e n c y urgency urgency：为了按时完成，每天需要投入的小时数------一个可直接行动的指标

urgency 随 deadline 逼近趋近无穷大，语义上"再不推进就来不及了"。该值不参与状态传播和 M 加权，只在规划、优先级排序和自动提示中使用。

估算校准 ：系统中已记录的劳动投入 C ⃗ \vec{C} C 可以反检预估的准确性。累计投入接近 W ^ \hat{W} W^ 但 D/L/T 远未达到 1，说明初始低估了。"你的同类任务历史平均低估 1.8 倍"这类反馈可以作为用户设 deadline 时的参考。

2.3 边的意义

父子边上的 M 是这个系统的核心设计。它回答一个问题："一个子节点完成的程度，对父节点有多大的贡献？"

M 是一个 0~1 的数值：

M = 0：子节点的完成对父节点毫无贡献（存在但无关紧要）
M = 0.5：子节点完成一半，父节点获得一半的贡献
M = 1：子节点完成意味着父节点相应维度的完成

M 是边的属性，不是节点的属性。 同一个子节点对不同父节点可以有不同的 M：

复制代码

枝A（登录模块）           枝B（安全审计）
      \                      /
       \                    /
       子节点: 研究 OAuth 库
       M_A = 0.7            M_B = 0.3

2.4 任务的类型

DAG 中节点只有结构上的区别：

叶节点：没有子节点。它的状态变化只能来自单纯劳动直接指定它为受益节点。
枝节点：有子节点。它的状态变化既来自单纯劳动直接指定它为受益节点，也来自子节点通过 M 加权传播上来的状态。
根节点：没有父节点的节点。充当整个 DAG 的顶层聚合点。

三类节点使用完全相同的生命周期：创建时 S ⃗ = $0 , 0 , 0 , 0$ T \vec{S} = $0,0,0,0$ ^T S = $0,0,0,0$ T，每被某次单纯劳动指定为受益节点时累加 Δ S ⃗ \Delta\vec{S} ΔS ，到达 $1 , 1 , 1 , 1$ T $1,1,1,1$ ^T $1,1,1,1$ T 时闭环。

三、状态传播：M 加权聚合

3.1 设计问题

一次劳动评估在一个节点上（主要受益节点），如何影响它的祖先节点？

答案是：通过 M 权重自动向上传播。

3.2 聚合公式

父节点的 D 来自其所有子节点的 D 按 M 加权平均：

D p a r e n t ( c h i l d r e n ) = ∑ i = 1 n D i ⋅ M i ∑ i = 1 n M i D_{parent}^{(children)} = \frac{\sum_{i=1}^{n} D_i \cdot M_i}{\sum_{i=1}^{n} M_i} Dparent(children)=∑i=1nMi∑i=1nDi⋅Mi

L 和 T 同理。父节点的总 D 为：

D p a r e n t = D p a r e n t b e n e f i c i a r y + ( 1 − D p a r e n t b e n e f i c i a r y ) ⋅ ∑ D i ⋅ M i ∑ M i D_{parent} = D_{parent}^{beneficiary} + (1 - D_{parent}^{beneficiary}) \cdot \frac{\sum D_i \cdot M_i}{\sum M_i} Dparent=Dparentbeneficiary+(1−Dparentbeneficiary)⋅∑Mi∑Di⋅Mi

其中 D p a r e n t b e n e f i c i a r y D_{parent}^{beneficiary} Dparentbeneficiary 是所有以该节点为主要受益节点的单纯劳动积累的 D 值。

设计选择：子节点贡献只填补剩余空间。 当父节点已有部分直接完成度时，子节点聚合只作用于尚未完成的 1 − D p a r e n t b e n e f i c i a r y 1 - D_{parent}^{beneficiary} 1−Dparentbeneficiary 部分，保证总 D 永不溢出 $0 , 1$ $0,1$ $0,1$ 。

这个公式的经济学含义：一个项目的总体完成度，不是所有子任务的完成度之和------而是每个子任务的完成度按它的重要性加权平均。不重要的子任务完成了也不怎么影响大局，重要的子任务完成了就大幅推进。父节点自身的直接劳动推进得越多，子节点剩余可贡献的空间就越小------这避免了"子节点全部完成时父节点超过 1.0"的数学不一致。

3.3 递归传播

当一个单纯劳动的主要受益节点是叶节点时：

叶节点的状态更新： S ⃗ n e w = S ⃗ o l d + Δ S ⃗ \vec{S}{new} = \vec{S}{old} + \Delta\vec{S} S new=S old+ΔS
叶节点的父节点自动重算： D p a r e n t = D p a r e n t b e n e f i c i a r y + ( 1 − D p a r e n t b e n e f i c i a r y ) ⋅ ∑ D i ⋅ M i ∑ M i D_{parent} = D_{parent}^{beneficiary} + (1 - D_{parent}^{beneficiary}) \cdot \frac{\sum D_i \cdot M_i}{\sum M_i} Dparent=Dparentbeneficiary+(1−Dparentbeneficiary)⋅∑Mi∑Di⋅Mi
祖父节点同理递归------每一层都使用自己的子节点的 M 做加权聚合

用户不需要为每一层祖先做独立评估。 这是"只评估一次"的数学基础。

3.4 传播的边界

自动传播沿着 DAG 的父子边向上单向进行。当一次劳动的产出跨越了 DAG 结构（比如它影响到了主要受益节点所在分支之外的节点），自动传播覆盖不到------这时用户通过"额外影响节点"手动指定。

四、学习机制：转化矩阵 G

4.1 设计问题

用户记录劳动投入 C 和产出 ΔS。但不同的劳动效率不同------同样的 2 小时编码，有人能写 80% 的功能，有人只能写 30%。系统如何从用户的记录中学习效率特征？

4.2 矩阵结构

转化矩阵 G 建立了投入和产出之间的映射：

Δ S ⃗ = G ⋅ C ⃗ \Delta\vec{S} = G \cdot \vec{C} ΔS =G⋅C

G 是一个 4 × 3 4 \times 3 4×3 矩阵，4 行对应 D/L/T/M，3 列对应 Do/Learn/Think：

G = $g D D g D L g D T g L D g L L g L T g T D g T L g T T g M D g M L g M T$ G = \begin{bmatrix} g_{DD} & g_{DL} & g_{DT} \\ g_{LD} & g_{LL} & g_{LT} \\ g_{TD} & g_{TL} & g_{TT} \\ g_{MD} & g_{ML} & g_{MT} \end{bmatrix} G= gDDgLDgTDgMDgDLgLLgTLgMLgDTgLTgTTgMT

列的物理含义（向前看）："投入 1 单位 Do/Learn/Think，转化为多少 D/L/T/M？"

Do 列 $g D D , g L D , g T D , g M D$ T $g_{DD}, g_{LD}, g_{TD}, g_{MD}$ ^T $gDD,gLD,gTD,gMD$ T：执行 1 小时带来的变化
Learn 列 $g D L , g L L , g T L , g M L$ T $g_{DL}, g_{LL}, g_{TL}, g_{ML}$ ^T $gDL,gLL,gTL,gML$ T：学习 1 小时带来的变化
Think 列 $g D T , g L T , g T T , g M T$ T $g_{DT}, g_{LT}, g_{TT}, g_{MT}$ ^T $gDT,gLT,gTT,gMT$ T：思考 1 小时带来的变化

行的物理含义（向后看）："ΔD/ΔL/ΔT/ΔM 各来自哪些投入？"

D 行 $g D D , g D L , g D T$ $g_{DD}, g_{DL}, g_{DT}$ $gDD,gDL,gDT$ ：完成度的提升来自执行、学习、还是思考
L 行 $g L D , g L L , g L T$ $g_{LD}, g_{LL}, g_{LT}$ $gLD,gLL,gLT$ ：学习量的提升来自执行、学习、还是思考
T 行 $g T D , g T L , g T T$ $g_{TD}, g_{TL}, g_{TT}$ $gTD,gTL,gTT$ ：思考量的提升来自执行、学习、还是思考
M 行 $g M D , g M L , g M T$ $g_{MD}, g_{ML}, g_{MT}$ $gMD,gML,gMT$ ：重要性认知的变化来自执行、学习、还是思考

矩阵元素可以为负值------这是 CDMS 区别于传统进度系统的关键能力。一次学习可能发现之前的方向错了（D 回退），一次思考可能推翻既有方案（D 回退）。这些不是 bug，是认知工作的真实特征。

4.3 自动标定

设计决策：用户不需要也不应该直接填写 G 矩阵。

系统交互中用户只写两层数据：

投入记录：填写 C（做了什么、花了多少时间）
状态确认：填写 ΔS（对主要受益节点的 D/L/T/M 变化评估）

系统自动从 G ⋅ C ⃗ = Δ S ⃗ G \cdot \vec{C} = \Delta\vec{S} G⋅C =ΔS 反推出被激活的那一列。由于 C 是单热向量，只激活 G 的一列------4 条方程解 3 个未知数，唯一确定。

4.4 数值案例

案例 1：纯执行（机械编码）

投入 2h 执行，只有 D 推进了：

G = $0.40 0 0 0 0 0 0 0 0 0 0 0$ , C ⃗ = $2 0 0$ , Δ S ⃗ = $0.80 0 0 0$ G = \begin{bmatrix} 0.40 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 0 \end{bmatrix},\; \vec{C} = \begin{bmatrix} 2 \\ 0 \\ 0 \end{bmatrix},\; \Delta\vec{S} = \begin{bmatrix} 0.80 \\ 0 \\ 0 \\ 0 \end{bmatrix} G= 0.4000000000000 ,C = 200 ,ΔS = 0.80000

反推 Do 列： g D D = 0.80 / 2 = 0.40 g_{DD}=0.80/2=0.40 gDD=0.80/2=0.40，其余为 0。

案例 2：纯学习（内容输入）

投入 1h 学习，L 提升，同时也意识到任务更重要：

G = $0 0 0 0 0.50 0 0 0 0 0 0.15 0$ , Δ S ⃗ = $0 0.50 0 0.15$ G = \begin{bmatrix} 0 & 0 & 0 \\ 0 & 0.50 & 0 \\ 0 & 0 & 0 \\ 0 & 0.15 & 0 \end{bmatrix},\; \Delta\vec{S} = \begin{bmatrix} 0 \\ 0.50 \\ 0 \\ 0.15 \end{bmatrix} G= 000000.5000.150000 ,ΔS = 00.5000.15

反推 Learn 列： g L L = 0.50 g_{LL}=0.50 gLL=0.50， g M L = 0.15 g_{ML}=0.15 gML=0.15。

案例 3：纯思考（方案推演）

投入 2h 思考，T 提升，定位更清晰：

G = $0 0 0 0 0 0 0 0 0.45 0 0 0.10$ , Δ S ⃗ = $0 0 0.90 0.20$ G = \begin{bmatrix} 0 & 0 & 0 \\ 0 & 0 & 0 \\ 0 & 0 & 0.45 \\ 0 & 0 & 0.10 \end{bmatrix},\; \Delta\vec{S} = \begin{bmatrix} 0 \\ 0 \\ 0.90 \\ 0.20 \end{bmatrix} G= 00000000000.450.10 ,ΔS = 000.900.20

案例 4：执行产生溢出效应

投入 2h 执行，做的时候查了文档（L）、调 Bug 想通了原理（T）、发现该模块影响面很大（M）：

G = $0.30 0 0 0.06 0 0 0.04 0 0 0.03 0 0$ , Δ S ⃗ = $0.60 0.12 0.08 0.06$ G = \begin{bmatrix} 0.30 & 0 & 0 \\ 0.06 & 0 & 0 \\ 0.04 & 0 & 0 \\ 0.03 & 0 & 0 \end{bmatrix},\; \Delta\vec{S} = \begin{bmatrix} 0.60 \\ 0.12 \\ 0.08 \\ 0.06 \end{bmatrix} G= 0.300.060.040.0300000000 ,ΔS = 0.600.120.080.06

案例 5：学习导致认知回退

学习发现旧方案行不通，D 和 T 回退，但认识到该任务至关重要：

G = $0 - 0.15 0 0 0.60 0 0 - 0.10 0 0 0.25 0$ , Δ S ⃗ = $- 0.15 0.60 - 0.10 0.25$ G = \begin{bmatrix} 0 & -0.15 & 0 \\ 0 & 0.60 & 0 \\ 0 & -0.10 & 0 \\ 0 & 0.25 & 0 \end{bmatrix},\; \Delta\vec{S} = \begin{bmatrix} -0.15 \\ 0.60 \\ -0.10 \\ 0.25 \end{bmatrix} G= 0000−0.150.60−0.100.250000 ,ΔS = −0.150.60−0.100.25

g D L = − 0.15 g_{DL}=-0.15 gDL=−0.15 和 g T L = − 0.10 g_{TL}=-0.10 gTL=−0.10 为负------认知回退，这是 CDMS 区别于传统进度系统的核心能力。

案例 6：思考导致推翻重来

深度复盘后决定推翻既有实现，但战略定位更清晰：

G = $0 0 - 0.15 0 0 0.10 0 0 0.40 0 0 0.20$ , Δ S ⃗ = $- 0.30 0.20 0.80 0.40$ G = \begin{bmatrix} 0 & 0 & -0.15 \\ 0 & 0 & 0.10 \\ 0 & 0 & 0.40 \\ 0 & 0 & 0.20 \end{bmatrix},\; \Delta\vec{S} = \begin{bmatrix} -0.30 \\ 0.20 \\ 0.80 \\ 0.40 \end{bmatrix} G= 00000000−0.150.100.400.20 ,ΔS = −0.300.200.800.40

4.5 事件级别的 G

设计决策：G 不合并，是事件级别的。

每一次单纯劳动都对应一个独立的 G（或至少是被激活的那一列）。系统不会把多次劳动的 G 合并成一个"通用效率值"。这种设计允许用户观察自己效率的变化趋势：

复制代码

第 1 次编码 2h → G_1 的 Do 列 = [0.25, 0.08, 0.05, 0.02]^T
第 2 次编码 2h → G_2 的 Do 列 = [0.28, 0.07, 0.04, 0.03]^T
第 3 次编码 3h → G_3 的 Do 列 = [0.32, 0.06, 0.03, 0.02]^T

G 不做预测，而是做事后分析------把同类型事件的 G 列排在一起，用户能看到自己的效率与耦合特征的变化趋势。

五、全局拓扑：意义矩阵

5.1 从边的标量到全矩阵

前面讨论的都是 DAG 中父子边上的标量 M。当系统中有 n n n 个节点时，所有这些 M 值可以组织成一个 n × n n \times n n×n 矩阵：

M = $M 11 M 12 \dots M 1 n M 21 M 22 \dots M 2 n ⋮ ⋮ ⋱ ⋮ M n 1 M n 2 \dots M n n$ \mathbf{M} = \begin{bmatrix} M_{11} & M_{12} & \cdots & M_{1n} \\ M_{21} & M_{22} & \cdots & M_{2n} \\ \vdots & \vdots & \ddots & \vdots \\ M_{n1} & M_{n2} & \cdots & M_{nn} \end{bmatrix} M= M11M21⋮Mn1M12M22⋮Mn2⋯⋯⋱⋯M1nM2n⋮Mnn

M i j M_{ij} Mij = 节点 i 对节点 j 的意义。在 DAG 结构中 M c h i l d , p a r e n t > 0 M_{child,parent} > 0 Mchild,parent>0，但矩阵允许任意两个节点之间存在非零值。

5.2 行与列的意义

第 i 行 M i : \mathbf{M}_{i:} Mi: （固定 i，变化 j）："我（节点 i）的完成对谁有帮助？"

行 i 的非零元指向那些认为 i 重要的节点
在 DAG 中，行 i 的非零元指向 i 的所有祖先

第 j 列 M : j \mathbf{M}_{:j} M:j （固定 j，变化 i）："谁对节点 j 有意义？"

列 j 的非零元来自那些对 j 有贡献的节点
在 DAG 中，列 j 的非零元来自 j 的所有子孙

行是影响的扇出，列是依赖的扇入。 共同语义基础：意义从子流向父。

5.3 六个用途

用途一：全局重要性排序（特征向量中心性）

求解 M T ⋅ v ⃗ = λ v ⃗ \mathbf{M}^T \cdot \vec{v} = \lambda \vec{v} MT⋅v =λv 。主特征向量 v ⃗ \vec{v} v 给出每个节点的稳态重要性：

v i ∝ ∑ j M j i ⋅ v j v_i \propto \sum_j M_{ji} \cdot v_j vi∝j∑Mji⋅vj

节点 i 的重要性 = 所有认为 i 重要的节点的重要性 × 权重之和。与 PageRank 同构。

应用：在多个任务中选择优先推进哪个时，不依赖主观判断，而是从整个意义网络的拓扑中计算出系统级排序。

用途二：影响传播的统一算子（Leontief 逆矩阵）

核心思想 ：Leontief 逆矩阵 ( I − M ) − 1 (I-M)^{-1} (I−M)−1 是一个通用传播算子。给定任意初始扰动，它沿 DAG 所有父子路径传播，计算稳态累积结果。这是前面"只评估一次"的数学基础------用户只需要指定子节点的变化，系统自动算出它对整个 DAG 的影响。

视角 A --- 意义传递（结构分析）：输入 = M 本身（每个节点的意义扇出），输出 = 所有间接路径的累积意义：

M t o t a l = M + M 2 + M 3 + ⋯ = M ( I − M ) − 1 \mathbf{M}_{total} = \mathbf{M} + \mathbf{M}^2 + \mathbf{M}^3 + \cdots = \mathbf{M}(\mathbf{I} - \mathbf{M})^{-1} Mtotal=M+M2+M3+⋯=M(I−M)−1

应用：一个底层 Bug 修复对顶层目标的间接贡献是多少？自动计算出所有路径的累积效应。

视角 B --- 冲击响应（动态模拟） ：输入 = e ⃗ k \vec{e}_k e k（节点 k 发生了 1 单位状态变化），输出 = 该变化对所有节点的波及程度：

I m p a c t ⃗ k = ( I − M ) − 1 ⋅ e ⃗ k \vec{Impact}_k = (\mathbf{I} - \mathbf{M})^{-1} \cdot \vec{e}_k Impact k=(I−M)−1⋅e k

应用：某个子任务延期了，系统自动计算出哪些任务受影响及程度。

两视角的关系 ：同一台机器 ( I − M ) − 1 (I-M)^{-1} (I−M)−1，换了输入。视角 A 问"结构上的意义从哪来"，视角 B 问"某个变化传到哪去"。在实现中，两者共享同一个传播引擎。

用途三：注意力会计与认知负载分布

行归一化： R i j = M i j / ∑ j M i j R_{ij} = M_{ij} / \sum_j M_{ij} Rij=Mij/∑jMij 表示节点 i 的注意力分配给节点 j 的比例。

第 i 行和：节点 i 的认知辐散度（同时关注多少其他节点）
第 j 列和：节点 j 被多少节点关注（众矢之的程度）
行和的信息熵：认知负载均匀度------过高表示优先级稀释，过低表示隧道效应

应用：当 M 矩阵突然变密集（所有节点互相觉得重要），提示优先级不清晰；行熵可作为认知负载过重的早期预警。

用途四：工作优先级量化

结合完成度向量 D ⃗ \vec{D} D 和意义矩阵 M：

P r i o r i t y ⃗ = M T ⋅ ( 1 ⃗ − D ⃗ ) \vec{Priority} = \mathbf{M}^T \cdot (\vec{1} - \vec{D}) Priority =MT⋅(1 −D )

P r i o r i t y i = ∑ j M j i ⋅ ( 1 − D j ) Priority_i = \sum_j M_{ji} \cdot (1 - D_j) Priorityi=∑jMji⋅(1−Dj)：节点 i 的优先级 = 所有认为 i 重要的节点的剩余工作缺口加权和。

这里没有主观的"紧急 × 重要"打分------优先级从网络拓扑和完成度自动计算。

Deadline 调制

当节点设有 deadline 时，其紧急度可作为权重调制到优先级中：

P r i o r i t y i d e a d l i n e = ( 1 + α ⋅ u r g e n c y i u r g e n c y r e f ) ⋅ ∑ j M j i ⋅ ( 1 − D j ) Priority_i^{deadline} = \left(1 + \alpha \cdot \frac{urgency_i}{urgency_{ref}}\right) \cdot \sum_j M_{ji} \cdot (1 - D_j) Priorityideadline=(1+α⋅urgencyrefurgencyi)⋅j∑Mji⋅(1−Dj)

α \alpha α：全局参数，控制 deadline 对优先级的影响强度
u r g e n c y r e f urgency_{ref} urgencyref：归一化参考值（如系统均值或过去 7 天的滑动中位数），使不同时间段的紧急度可比较

调制后的优先级排序仍然以 M 矩阵的拓扑重要度为主干，deadline 只作为偏置因子------一个 deadline 逼近的不重要节点不会被调到比拓扑核心节点更高的位置。

用途五：执行顺序推荐（拓扑排序）

对 DAG 做拓扑排序（Kahn 算法或 DFS），得到满足依赖关系的执行顺序------子节点排在父节点之前。按此顺序排列节点，保证任意节点被推进时其依赖的前置条件已完成。

用途六：动力学特征量

M 矩阵随时间演化。通过对比不同时刻的 M 矩阵，可观察认知结构的变化：

行向量变化 Δ M i : \Delta \mathbf{M}_{i:} ΔMi:：节点 i 分配给其他节点的意义在一段时间内的变动总量，反映该节点正在重新评估什么重要、什么不重要------是认知重组的直接信号。

六、系统运作

6.0 任务网络管理

DAG（有向无环图）的构建和维护是系统运作的基础。劳动记录必须绑定到一个已有节点作为受益节点，因此用户需要先建立任务网络。

6.0.1 创建节点

字段	说明	必填	示例
节点名称	唯一标识节点	是	"OAuth 集成"
父节点	指定后自动创建边，M=0.5	否	"认证模块"
deadline	截止日期	否	2026-07-01
estimatedWorkload	预估总工作量(h)，有 deadline 时必填	否	40

创建时 S ⃗ = $0 , 0 , 0 , 0$ T \vec{S} = $0,0,0,0$ ^T S = $0,0,0,0$ T。

若不指定父节点，新节点成为独立根节点------系统至少需要有一个根节点才能形成完整传播路径。

6.0.2 创建边

边表示"子节点的完成对父节点的贡献程度"。创建边分两种场景：

场景 A --- 初始节点创建时附带

创建子节点时指定父节点，M 默认 0.5（规划阶段的合理假设，用户可直接填写期望值）：

字段	说明	必填	示例
子节点	贡献的发出方，完成度沿边向上传播	是	"方案调研"
父节点	贡献的接收方，聚合子节点的完成度	是	"OAuth 集成"
M 值	0~1，默认 0.5	否	0.7

场景 B --- 事后添加边（已有劳动记录的节点之间）

当一个节点已有劳动积累，用户后来才意识到它应当连接到某个父节点时，添加边不是一个纯结构操作------它是一次认知劳动：你花时间思考了两个节点之间的关系，然后设定了 M 值。

系统引导用户记录一条 Think 类型 劳动作为添加边的依据：

复制代码

示例：
  投入 C = [0, 0, 0.5]^T（思考 0.5h）
  受益节点: "方案调研"
  ΔS = [ΔD=0, ΔL=0, ΔT=0.3, ΔM=0.7]
  
  → G 的 Think 列: g_TT = 0.3/0.5 = 0.6, g_MT = 0.7/0.5 = 1.4
  → 边上的 M = 0.7 (由 ΔM 决定)

M 值不是用户凭空填写的，而是来自 G 矩阵 Think 列的输出：

M e d g e = Δ M = g M T ⋅ C T h i n k M_{edge} = \Delta M = g_{MT} \cdot C_{Think} Medge=ΔM=gMT⋅CThink

这种设计保证了：

边的 M 有劳动记录背书，不是无源的操作
G 矩阵事后分析可以检测到用户"是否擅长发现任务之间的关系"（ g M T g_{MT} gMT 大小反映这种能力）
删除或修改边时同样有 G 矩阵的记录可追溯

6.0.3 编辑节点

允许修改：

节点名称
规划属性（deadline、estimatedWorkload）

不允许手动修改状态向量 S ⃗ \vec{S} S ------状态只能由劳动记录驱动，保证数据一致性。

6.0.4 编辑边的 M 值

M 值的变更意味着用户对依赖关系的理解发生了变化------这是一次认知劳动，由 G 矩阵的 Think 列驱动。

用户记录一次 Think 劳动，其 Δ M \Delta M ΔM 决定新的 M 值：

复制代码

示例：
  原 M = 0.7，用户觉得估值偏高
  Think 0.3h → ΔS = [ΔD=0, ΔL=0, ΔT=0.1, ΔM=-0.2]
  新 M = 0.7 + (-0.2) = 0.5
  → G 的 Think 列: g_TT = 0.33, g_MT = -0.67

更新 M 后系统自动从该子节点出发向上重传播（走方案 B 聚合公式），所有祖先节点即时反映新的 M 权重。

允许直接编辑 M 的场景：初始 DAG 构建阶段（尚无劳动记录）。一旦系统有劳动记录，所有 M 变更必须通过劳动记录驱动。

6.0.5 删除节点

删除节点时弹出确认对话框，用户需选择劳动记录的处理策略：

处理策略	说明
保留记录	劳动记录保留在系统中，受益节点标记为"已删除"
迁移记录	将劳动记录迁移到用户指定的替代节点
级联删除	删除节点及其所有劳动记录

若被删除节点有子节点，需同时选择子节点的归属：

子节点提升到被删除节点的父节点（保持贡献传播链）
子节点一并删除

6.0.6 删除边

删除边意味着用户认知结构的变化------原以为的依赖关系不再成立。这也是一次认知劳动，由 G 矩阵驱动。

用户应记录一条 Think 劳动，其 Δ M \Delta M ΔM 用于抵消原边上的 M 值：

复制代码

示例：
  原边 M = 0.7，用户认为该依赖不成立
  Think 0.2h → ΔS = [ΔD=0, ΔL=0, ΔT=0.15, ΔM=-0.7]
  → G 的 Think 列: g_TT = 0.75, g_MT = -3.5
  → 支付 ΔM = -0.7 后，边被移除

删除边后，子节点若因此与上层网络断开（无父节点），系统提示：

为其指定一个新的父节点（需新建边并记录对应的 Think 劳动）
或保留其为独立根节点

允许直接删除边的场景：初始 DAG 构建阶段（尚无劳动记录）。一旦系统有劳动记录，删除边必须通过劳动记录驱动------即使 ΔM 为负，也是认知变化的真实记录。

6.1 记录一次劳动

用户在界面上完成一次劳动记录，系统依次执行四个步骤，每一步都有确定的输入和输出。

步骤一：记录原始数据

用户填写四个字段：

字段	说明	示例
投入 C ⃗ \vec{C} C	劳动时间和类型（只能一个类型非零）	$2 , 0 , 0$ T $2, 0, 0$ ^T $2,0,0$ T（编码 2h）
主要受益节点	此次劳动推进了哪个节点	"OAuth 集成"
产出评估 Δ S ⃗ \Delta\vec{S} ΔS	对该节点的 D/L/T/M 变化	$0.4 , 0.1 , 0.05 , 0$ T $0.4, 0.1, 0.05, 0$ ^T $0.4,0.1,0.05,0$ T
额外影响节点	可选，自动传播覆盖不到的其他节点	安全审计: $0 , 0.1 , 0.05 , 0$ T $0, 0.1, 0.05, 0$ ^T $0,0.1,0.05,0$ T

步骤二：推导 G 列

由于 C ⃗ \vec{C} C 只有一个分量非零，被激活的 G 列可直接解出。以编码 2h 为例， Δ S ⃗ = $0.4 , 0.1 , 0.05 , 0$ T \Delta\vec{S}= $0.4, 0.1, 0.05, 0$ ^T ΔS = $0.4,0.1,0.05,0$ T，激活的 Do 列各元素：

g D D = 0.4 / 2 = 0.20 , g L D = 0.1 / 2 = 0.05 , g T D = 0.05 / 2 = 0.025 , g M D = 0 / 2 = 0 g_{DD}=0.4/2=0.20,\quad g_{LD}=0.1/2=0.05,\quad g_{TD}=0.05/2=0.025,\quad g_{MD}=0/2=0 gDD=0.4/2=0.20,gLD=0.1/2=0.05,gTD=0.05/2=0.025,gMD=0/2=0

该 G 列作为本次劳动的子记录保存。

步骤三：更新节点状态

主要受益节点的状态即时更新：

S ⃗ n e w = S ⃗ o l d + Δ S ⃗ \vec{S}{new} = \vec{S}{old} + \Delta\vec{S} S new=S old+ΔS

示例------"OAuth 集成"原状态 $0.3 , 0.4 , 0.2 , 0$ T $0.3, 0.4, 0.2, 0$ ^T $0.3,0.4,0.2,0$ T，更新后为 $0.7 , 0.5 , 0.25 , 0$ T $0.7, 0.5, 0.25, 0$ ^T $0.7,0.5,0.25,0$ T。

若有额外影响节点，对它也做同样更新，但 G 列仍以主要受益节点的 Δ S ⃗ \Delta\vec{S} ΔS 为准（额外影响是用户手动指定的独立评估，不代入 G 推导）。

步骤四：向上传播

从受益节点出发，沿父边递归更新祖先节点。每层使用方案 B 聚合公式：

L、T 同理。传播停止在根节点------至此一次劳动记录完成，系统进入新状态。

6.2 记录维护

劳动记录是系统数据的根源，可能因录入错误、理解偏差或范围变更需要修正。以下操作均需在修改前确认用户意图。

6.2.1 编辑劳动记录

允许修改的字段：

字段	修改影响	说明
投入 C ⃗ \vec{C} C	重算 G 列 + 重传播	修改劳动时间和类型
主要受益节点	撤销原节点影响，应用到新节点	改变受益目标
产出评估 Δ S ⃗ \Delta\vec{S} ΔS	重算 G 列 + 重传播	修正评估偏差
额外影响节点	重算额外影响	新增/移除/修改额外节点

修改流程：

用户修改任意字段
系统撤销此次劳动的原始影响（从受益节点减去 Δ S ⃗ \Delta\vec{S} ΔS ，然后向上逆传播）
按新值重新执行步骤一至四（推导 G 列 → 更新节点状态 → 向上传播）
若 G 列发生变化，此条劳动关联的 G 列子记录同步更新

逆传播：撤销一次劳动的影响时，对祖先节点同样执行逆聚合。但若有其他劳动在同一时间段内影响了同一节点，逆传播可能无法精确还原------此时系统提示"该劳动的部分影响与其他劳动叠加，撤销后状态为近似值"。

6.2.2 删除劳动记录

删除劳动记录彻底移除其所有影响：

撤销该劳动对受益节点及所有祖先节点的状态变化（同编辑的逆传播）
删除该劳动记录及其关联的 G 列子记录
该劳动不再出现在时间线查询和投入汇总中

前置检查：

若该劳动是某个节点的唯一劳动记录，删除后该节点回到初始 $0 , 0 , 0 , 0$ T $0,0,0,0$ ^T $0,0,0,0$ T 状态
若该劳动记录的 G 列被 4.5 节的趋势分析引用，趋势图表中该点被移除，均值自动重算

6.2.3 节点状态手动修正

在以下场景中，允许用户直接修正节点的状态向量：

场景	说明
初始种子值	迁移旧数据或已有成果时，设置节点的初始 D/L/T
明显录入错误	某次劳动导致 D 从 0.3 跳到 0.9 但实际只有 0.4，可手动回调
范围重定义	节点范围变更后，调整状态反映新范围

修正记录：每次手动修正生成一条日志记录（修正时间、修正前后值、原因备注），与劳动记录一样参与归因追溯，但在界面中标记为"手动修正"而非劳动记录。

6.3 查询与分析

系统不下结论，只对已记录的数据做计算并将结果呈现给用户。

时间线查询

输入起止时间，输出按时间排列的劳动记录列表，每条附带 G 列和传播后各祖先节点的状态变化。示例：

复制代码

2026-06-02 14:00-16:00  编码  OAuth集成  [ΔD=0.4, ΔL=0.1, ΔT=0.05]
  └─ 传播影响:
      OAuth集成: D 0.3→0.7
      └─ 认证模块: D 0.4→0.55 (M=0.6)
          └─ 产品上线: D 0.2→0.28 (M=0.5, 再传播)

节点状态演化图

输入任意节点，输出该节点每个维度在时间轴上的变化曲线，标注每次劳动（或传播事件）的贡献来源。示例：

复制代码

OAuth 集成 --- D 的变化
 1.0 ┤
     │          ●(0.7) ← 本次劳动(编码)
 0.5 ┤    ●(0.5)
     │ ●(0.3)
     │●(0.0)
     └────────────────────→ t
       5/28  6/01  6/02

投入汇总

输入任意节点范围和时间范围，聚合各类劳动的总投入量。结果是一个简单的分类计数：

复制代码

2026年5月  OAuth集成 及其子节点:
  编码: 12h (3次)
  学习:  4h (2次)
  思考:  1h (1次)
  合计: 17h

归因追溯

输入一个上层节点，输出其当前状态中有多少来自哪些节点、哪些劳动的累积贡献。系统沿着传播路径反向追溯，每一步标记贡献来源的节点和 Δ S ⃗ \Delta\vec{S} ΔS 份额。

复制代码

"用户系统" D=0.65 的来源:
  来自 "登录页" 的直接劳动:
    ● 5/28 编码2h → ΔD贡献: 0.15
    ● 6/01 编码1h → ΔD贡献: 0.08
  来自 "注册流程" 的直接劳动:
    ● 5/30 编码3h → ΔD贡献: 0.22
  来自 OAuth 集成的传播:
    ● 6/02 编码2h → ΔD贡献: 0.12 (经M=0.6加权)

6.3.5 G 列趋势分析

输入同类劳动的时间范围，输出该类型 G 列各元素在时间轴上的变化曲线，标注每次劳动记录。示例：

复制代码

编码劳动的 g_DD 趋势（最近 10 次）:
  g_DD/h
  0.40 ┤        ●(0.38)
  0.30 ┤  ●(0.28)        ●(0.32)
  0.20 ┤●(0.20)    ●(0.25)
       └─────────────────────────→ 记录序号
         #1   #2   #3   #4   #5
  趋势: 近期编码效率从 0.20/h 上升到 0.32/h
  标准差: 0.065 (中等波动)

若某列元素为负值（认知回退），在图中以不同颜色标记。均值线和 ±1σ 区间作为参考叠加。

6.3.6 M 矩阵全景视图

以矩阵热力图展示当前 DAG 中所有节点的 M 值：

行 = 子节点（影响的扇出），列 = 父节点（依赖的扇入）
格子颜色深度 = M 值大小
悬停显示具体数值

视图上方提供筛选器：按节点名称搜索高亮，或选择只显示"活跃节点"（最近 14 天有劳动记录的节点）。

6.3.7 全局重要性排序

基于特征向量中心性（见 5.3 用途一），计算并显示所有节点的稳态重要性排名：

复制代码

全局重要性排序（特征向量中心性）:
  Rank  Node                Score
  1     OAuth 集成          0.324
  2     用户系统            0.287
  3     认证模块            0.215
  4     安全审计            0.103
  5     注册流程            0.071

  释义: 重要性来自"所有认为你重要的节点的重要性加权之和"。
  拓扑核心：OAuth 集成 和 用户系统 处于网络的核心位置。

输入任意节点则显示其重要性分数分解：哪些节点认为它重要、各自贡献了多少权重。

6.3.8 优先级量化视图

基于 P r i o r i t y = M T ⋅ ( 1 ⃗ − D ⃗ ) Priority = \mathbf{M}^T \cdot (\vec{1} - \vec{D}) Priority=MT⋅(1 −D )（见 5.3 用途四），计算并显示所有节点的优先级排序：

复制代码

当前优先级排序:
  Rank  Node             Priority  缺口(D)  缺口(L)  缺口(T)
  1     方案调研          0.72      0.70     0.85     0.75
  2     OAuth 集成       0.58      0.30     0.50     0.75
  3     编码实现          0.41      0.40     0.70     0.60

  释义: 优先级 = 所有认为你重要的节点的剩余缺口加权和。
  方案调研 的优先级最高，因为它处于 DAG 的底层瓶颈位置。

设有 deadline 的节点，其紧急度以 ( 1 + α ⋅ u r g e n c y / u r g e n c y r e f ) (1 + \alpha \cdot urgency/urgency_{ref}) (1+α⋅urgency/urgencyref) 乘到优先级上，在排名中标示 deadline 倒计时。

6.3.9 拓扑排序推荐

对当前 DAG 做拓扑排序，输出满足依赖关系的执行顺序：

复制代码

推荐执行顺序（拓扑排序）:
  1. 方案调研          ← 无前置依赖，建议优先推进
  2. OAuth 集成
  3. 编码实现
  4. 用户系统
  5. 注册流程
  6. 安全审计

排序结果中标注阻塞链上节点的优先推进标记。

6.3.10 Leontief 影响域分析

输入一个节点，计算若该节点发生单位状态变化 ( e ⃗ k \vec{e}_k e k) 后，通过 ( I − M ) − 1 (I-M)^{-1} (I−M)−1 传播到各节点的稳态影响（见 5.3 用途二）：

复制代码

影响域分析 --- "方案调研" 的变化会波及:
  节点                  直接影响  间接影响  总影响
  方案调研               1.000     0.000     1.000
  └─ OAuth 集成          0.000     0.400     0.400 (M=0.4)
     └─ 用户系统          0.000     0.200     0.200 (再传播)
     └─ 认证模块          0.000     0.120     0.120 (再传播)

  释义: 方案调研 完成 1 单位，预计带动 OAuth 集成 完成 0.4 单位。

可切换视角：影响传递（M总）和冲击响应（Impact）。两种视角共享同一传播引擎。

6.4 辅助规划

用户打开系统规划下一步时，系统基于当前状态提供计算结论，不依赖 G 做预测。

维度缺口

对任意节点，输出 D/L/T/M 各自距离 1 的差值，按大小排列。这是纯数学运算，不涉及任何估计。

复制代码

OAuth 集成:
  当前状态: [D=0.70, L=0.50, T=0.25, M=0]
  缺口: T=0.75 > L=0.50 > D=0.30 > M=0
  → 当前最薄弱的维度: T（思考收敛度）

阻塞链

从任意节点出发，沿子→父方向找到 D 值连续偏低的最长路径。链上第一个节点是最高优的干预点------它卡住了后续所有节点。

复制代码

阻塞链: OAuth(父D=0.70) → 方案调研(子D=0.30)
                                         ↑ 最高优
  → 方案调研的 T=0.15，说明方案本身没想清楚
  → 此时在父节点 OAuth 上编码效率有限

近完成节点

遍历 DAG 中所有节点，筛选出 min ⁡ ( D , L , T ) ≥ 0.9 \min(D,L,T) \geq 0.9 min(D,L,T)≥0.9 的节点。这些节点的剩余投入最多带来 0.1 的变化，应当将精力转到其他节点。

结构假设推演

输入一个节点，系统假设其所有子节点都达到 D=1，然后通过聚合公式计算其父节点的 D 会提升多少。这是确定性计算，不涉及 G。

复制代码

假设: 方案调研 → D=1.0
父节点 OAuth 集成当前 D=0.70
聚合子节点: 方案调研(D=1.0, M=0.4), 编码实现(D=0.6, M=0.8)
加权平均: (1.0×0.4 + 0.6×0.8)/(0.4+0.8) = 0.88/1.2 = 0.73
OAuth 新 D = 0.0 + (1-0.0)×0.73 = 0.73
(注: OAuth 的 direct beneficiary D=0，所有D来自子节点)

6.5 自动提示

系统以劳动记录为驱动，每次记录后检查以下条件，满足时推送一条消息。

效率漂移

当某类劳动的 G 列某元素最近 N 次的均值偏离更早 N 次的均值超过 ±20% 时推送。示例消息：

复制代码

你的编码效率（g_DD）最近5次均值为0.18/h，
此前5次均值为0.28/h，下降了36%。
是否需要检查遇到了什么阻碍？

投入结构失衡

当一个节点过去的 N 次劳动的 C ⃗ \vec{C} C 中某一类型占比超过 80% 时推送。示例消息：

复制代码

"OAuth 集成" 最近5次劳动全部是编码。
该节点当前 T=0.25（缺口最大），L=0.50。
建议补充学习和思考再继续编码。

活跃-停滞边界

当一个节点超过 14 天没有劳动记录，但其子节点有最近 7 天内的劳动记录时推送。示例消息：

复制代码

"OAuth 集成" 已停滞15天。
但其子节点"方案调研" 3天前有新的学习记录。
父节点未动但子节点在推进------是否该重新评估OAuth的结构？

Deadline 预警

当一个设有 deadline 的节点的 u r g e n c y urgency urgency 持续大于过去 14 天该节点的日均投入时推送。示例消息：

复制代码

"方案调研" 剩余工作量估计 20h，距离 deadline 还有 5 天。
需要每天投入 4h 才能按时完成。
过去 7 天你在这个节点上日均投入 1.2h，缺口 2.8h/天。
⚠ 建议调整投入或重新评估工作范围。

6.6 节点生命周期管理

6.6.1 节点归档

当一个节点的 min ⁡ ( D , L , T ) ≥ 0.95 \min(D, L, T) \geq 0.95 min(D,L,T)≥0.95 时，系统提示用户是否归档该节点：

复制代码

"方案调研" 的 D=0.98, L=0.95, T=1.0，已接近完成。
是否归档该节点？归档后：
- 该节点标记为"已完成"，不再参与日常查询（除非显式打开"已归档"筛选）
- 其状态 $\vec{S}$ 锁定在当前值，不再变化
- 对父节点的贡献固定为当前 M 加权值
- 劳动记录和历史数据保留，可随时回溯

用户也可主动对任意节点发起归档操作。

6.6.2 归档后的查询

已归档节点在以下场景中仍然可见：

归因追溯：父节点的归因追溯中，已归档子节点的贡献标记为"已完成"并显示锁定值
时间线：归档前的劳动记录正常显示
影响域分析：已归档节点作为传播链中的中间节点，其锁定状态以虚线圈标示
投入汇总：归档前的劳动投入正常计入汇总

已归档节点不参与以下计算：

全局重要性排序（特征向量中心性）
优先级量化
阻塞链分析
自动提示检查

6.6.3 取消归档

允许将已归档节点恢复为活跃状态。取消归档后：

节点状态 S ⃗ \vec{S} S 保持归档时的锁定值
重新参与所有计算
新的劳动记录可正常指向该节点

6.7 系统设置

6.7.1 全局参数

用户可配置以下系统参数：

参数	默认值	说明
α \alpha α	0.3	deadline 对优先级的调制强度
效率漂移阈值	±20%	触发效率漂移提示的偏差幅度
投入结构失衡阈值	80%	触发投入失衡提示的单类型占比
活跃-停滞边界	14 天	判定父节点停滞的无劳动天数
活跃-停滞子节点窗口	7 天	判定子节点活跃的有劳动天数
异常劳动标准差倍数	2σ	触发异常标记的标准差倍数
近完成节点阈值	0.9	判定"近完成"的 min(D,L,T) 下限

6.7.2 通知管理

用户可以查看、确认和清理自动提示：

通知中心：集中展示所有未读提示，按时间排序
确认/忽略：每条提示可标记为"已读"或"忽略"
提示历史：查看已确认或已忽略的提示记录
频次控制：对同一类型的提示设置最小间隔时间，避免重复推送

6.7.3 数据管理

操作	说明
导出数据	将劳动记录、节点状态、G 列数据导出为 JSON 或 CSV
导入数据	从 JSON 导入（仅限系统导出格式，用于迁移或备份恢复）
数据统计	显示系统总劳动记录数、总投入小时数、DAG 节点数等基本指标

附录一：符号表

状态与向量

S ⃗ = D , L , T , M T \vec{S} = D, L, T, M^T S =D,L,T,MT --- 状态向量
- D D D --- Done，执行完成度， $0 , 1$ $0,1$ $0,1$
- L L L --- Learnt，学习内化度， $0 , 1$ $0,1$ $0,1$
- T T T --- Thought，思考收敛度， $0 , 1$ $0,1$ $0,1$
- M M M --- Meaning，意义/重要性。在 DAG 中为子对父的重要性；在全拓扑矩阵中 M i j M_{ij} Mij 为节点 i 对节点 j 的意义， $0 , 1$ $0,1$ $0,1$
S ⃗ ∗ = $1 , 1 , 1 , 1$ T \vec{S}^* = $1,1,1,1$ ^T S ∗= $1,1,1,1$ T --- 完美目标态
C ⃗ = c D , c L , c T T \vec{C} = c_D, c_L, c_T^T C =cD,cL,cTT --- 投入向量
- c D c_D cD --- 执行投入量
- c L c_L cL --- 学习投入量
- c T c_T cT --- 思考投入量
1 ⃗ \vec{1} 1 --- 全 1 向量
e ⃗ k \vec{e}_k e k --- 第 k 个标准基向量

转化矩阵

G ∈ R 4 × 3 G \in \mathbb{R}^{4\times 3} G∈R4×3 --- 转化矩阵
- g D D , g L D , g T D , g M D g_{DD}, g_{LD}, g_{TD}, g_{MD} gDD,gLD,gTD,gMD --- Do 列（执行效率）
- g D L , g L L , g T L , g M L g_{DL}, g_{LL}, g_{TL}, g_{ML} gDL,gLL,gTL,gML --- Learn 列（学习效率）
- g D T , g L T , g T T , g M T g_{DT}, g_{LT}, g_{TT}, g_{MT} gDT,gLT,gTT,gMT --- Think 列（思考效率）

意义矩阵

M ∈ 0 , 1 n × n \mathbf{M} \in 0,1^{n\times n} M∈0,1n×n --- 全拓扑意义矩阵
- M i : \mathbf{M}_{i:} Mi: --- 第 i 行，节点 i 的意义流向
- M : j \mathbf{M}_{:j} M:j --- 第 j 列，节点 j 的意义来源
I \mathbf{I} I --- 单位矩阵
λ \lambda λ --- 特征值
v ⃗ \vec{v} v --- 主特征向量（全局重要性排序）
ρ ( M ) \rho(\mathbf{M}) ρ(M) --- 谱半径
∥ M ∥ \|\mathbf{M}\| ∥M∥ --- 矩阵范数
R i j = M i j / ∑ j M i j R_{ij} = M_{ij} / \sum_j M_{ij} Rij=Mij/∑jMij --- 行归一化注意力分布
P r i o r i t y ⃗ \vec{Priority} Priority --- 优先级向量
I m p a c t ⃗ k \vec{Impact}_k Impact k --- 节点 k 的影响域向量

附录二：公式汇总

状态更新

S ⃗ k = S ⃗ k − 1 + G k ⋅ C ⃗ k \vec{S}{k} = \vec{S}{k-1} + G_k \cdot \vec{C}_k S k=S k−1+Gk⋅C k

新状态 = 旧状态 + 转化矩阵 × 投入向量。四种状态（D/L/T/M）与三种投入（Do/Learn/Think）通过 G 建立映射。

M 的演化

Δ M = g M D ⋅ c D + g M L ⋅ c L + g M T ⋅ c T \Delta M = g_{MD} \cdot c_D + g_{ML} \cdot c_L + g_{MT} \cdot c_T ΔM=gMD⋅cD+gML⋅cL+gMT⋅cT

意义变化是三种投入的副产品，由 G 矩阵的 M 行驱动。

M 加权聚合

D p a r e n t ( c h i l d r e n ) = ∑ i D i ⋅ M i ∑ i M i D_{parent}^{(children)} = \frac{\sum_i D_i \cdot M_i}{\sum_i M_i} Dparent(children)=∑iMi∑iDi⋅Mi

父节点的完成度 = 子节点的 D 按 M 加权平均。L 和 T 同理。

父节点总 D = 直接作为受益节点获得的部分 + 子节点加权聚合部分（只填补剩余空间）。

前向预测

S ⃗ p r e d = S ⃗ c u r + G r e c e n t ⋅ C ⃗ p l a n \vec{S}{pred} = \vec{S}{cur} + G_{recent} \cdot \vec{C}_{plan} S pred=S cur+Grecent⋅C plan

特征向量中心性

M T ⋅ v ⃗ = λ v ⃗ , v i ∝ ∑ j M j i ⋅ v j \mathbf{M}^T \cdot \vec{v} = \lambda \vec{v}, \quad v_i \propto \sum_j M_{ji} \cdot v_j MT⋅v =λv ,vi∝j∑Mji⋅vj

影响传播（Leontief 逆矩阵）

视角 A --- 意义传递：

视角 B --- 冲击响应：

I m p a c t ⃗ k = ( I − M ) − 1 ⋅ e ⃗ k \vec{Impact}_k = (\mathbf{I} - \mathbf{M})^{-1} \cdot \vec{e}_k Impact k=(I−M)−1⋅e k

两者共享同一传播算子 ( I − M ) − 1 (I-M)^{-1} (I−M)−1，只是输入不同。

注意力分布

R i j = M i j / ∑ j M i j R_{ij} = M_{ij} \big/ \sum_j M_{ij} Rij=Mij/j∑Mij

优先级量化

P r i o r i t y ⃗ = M T ⋅ ( 1 ⃗ − D ⃗ ) \vec{Priority} = \mathbf{M}^T \cdot (\vec{1} - \vec{D}) Priority =MT⋅(1 −D )

P r i o r i t y i = ∑ j M j i ⋅ ( 1 − D j ) Priority_i = \sum_j M_{ji} \cdot (1 - D_j) Priorityi=j∑Mji⋅(1−Dj)

系统核心哲学 ：

S ⃗ t + 1 = S ⃗ t + G t ⋅ C ⃗ t \vec{S}_{t+1} = \vec{S}_t + G_t \cdot \vec{C}_t S t+1=S t+Gt⋅C t

每个时刻有三种选择（Do/Learn/Think），每种选择以特征化的效率产生状态变化，系统在时间中留下一条 S ⃗ 0 → S ⃗ 1 → ⋯ → S ⃗ N \vec{S}_0 \to \vec{S}_1 \to \dots \to \vec{S}_N S 0→S 1→⋯→S N 的认知演化轨迹。