dsh-learn-space 0.0.0-stage → 1.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +21 -0
- package/README.md +46 -2
- package/assets/mermaid.min.js +2811 -0
- package/client.js +1740 -0
- package/cordis.patch.yml +8 -0
- package/icon.svg +8 -0
- package/index.js +1226 -0
- package/locale/en.json +6 -0
- package/locale/zh.json +6 -0
- package/package.json +56 -3
- package/quiz.js +218 -0
- package/skills/quiz/SKILL.md +37 -0
- package/skills/teach/SKILL.md +165 -0
package/locale/en.json
ADDED
package/locale/zh.json
ADDED
package/package.json
CHANGED
|
@@ -1,6 +1,59 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "dsh-learn-space",
|
|
3
|
-
"version": "
|
|
4
|
-
"
|
|
5
|
-
"
|
|
3
|
+
"version": "1.1.0",
|
|
4
|
+
"description": "学习空间:AI 辅导的个人学习面板。摸底定位 → 依赖图规划 → 逐节点教学 + quiz 确认,进度/笔记/错题/学习记录沉淀为 Markdown,支持导出自包含 HTML 学习报告。",
|
|
5
|
+
"keywords": [
|
|
6
|
+
"dsh",
|
|
7
|
+
"dsh-plugin",
|
|
8
|
+
"deepseek-harness",
|
|
9
|
+
"learning",
|
|
10
|
+
"ai-tutor",
|
|
11
|
+
"education",
|
|
12
|
+
"quiz",
|
|
13
|
+
"knowledge-graph"
|
|
14
|
+
],
|
|
15
|
+
"repository": {
|
|
16
|
+
"type": "git",
|
|
17
|
+
"url": "git+https://github.com/RCliang/dsh-learning-space.git",
|
|
18
|
+
"directory": "plugin"
|
|
19
|
+
},
|
|
20
|
+
"license": "MIT",
|
|
21
|
+
"type": "module",
|
|
22
|
+
"main": "index.js",
|
|
23
|
+
"exports": {
|
|
24
|
+
".": "./index.js",
|
|
25
|
+
"./client": "./client.js",
|
|
26
|
+
"./locale/*.json": "./locale/*.json",
|
|
27
|
+
"./icon": "./icon.svg",
|
|
28
|
+
"./package.json": "./package.json"
|
|
29
|
+
},
|
|
30
|
+
"files": [
|
|
31
|
+
"index.js",
|
|
32
|
+
"quiz.js",
|
|
33
|
+
"client.js",
|
|
34
|
+
"cordis.patch.yml",
|
|
35
|
+
"locale/*.json",
|
|
36
|
+
"icon.svg",
|
|
37
|
+
"assets/mermaid.min.js",
|
|
38
|
+
"skills",
|
|
39
|
+
"LICENSE",
|
|
40
|
+
"README.md"
|
|
41
|
+
],
|
|
42
|
+
"scripts": {
|
|
43
|
+
"prepublishOnly": "node -e \"require('fs').cpSync('../skills','skills',{recursive:true})\""
|
|
44
|
+
},
|
|
45
|
+
"engines": {
|
|
46
|
+
"node": ">=20"
|
|
47
|
+
},
|
|
48
|
+
"dsh": {
|
|
49
|
+
"bundle": { "patch": "./cordis.patch.yml" },
|
|
50
|
+
"client": {
|
|
51
|
+
"platform": "web",
|
|
52
|
+
"immediately": true,
|
|
53
|
+
"inject": [
|
|
54
|
+
"@deepseek-ai/dsh-client-runtime",
|
|
55
|
+
"@deepseek-ai/dsh-client-ui-sidebar"
|
|
56
|
+
]
|
|
57
|
+
}
|
|
58
|
+
}
|
|
6
59
|
}
|
package/quiz.js
ADDED
|
@@ -0,0 +1,218 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* quiz 出题/作答/反馈的确定性解析(纯函数)+ 幂等落盘。
|
|
3
|
+
* 格式契约见 skills/quiz/SKILL.md:
|
|
4
|
+
* 题号行 **第 N / M 题 · 节点**、题干、A. ~ D. 裸选项;
|
|
5
|
+
* 作答是单字母或「我选 B」;反馈首行以 ✅/❌ 开头。
|
|
6
|
+
* 正则均做容错(空格可省、标点变体),不命中一律降级为普通文本,不误伤。
|
|
7
|
+
*/
|
|
8
|
+
import { readFile, writeFile, mkdir, appendFile } from 'node:fs/promises'
|
|
9
|
+
import path from 'node:path'
|
|
10
|
+
|
|
11
|
+
// 题号行:**第 2 / 5 题 · 离散采样**(节点可缺省,数字两侧容忍空格)
|
|
12
|
+
export const RE_QHEAD = /^\*\*\s*第\s*(\d+)\s*\/\s*(\d+)\s*题\s*(?:·\s*([^*\n]+?))?\s*\*\*\s*$/
|
|
13
|
+
// 选项行:行首字母 + . / 、 / ) (容忍全角),选项文本非空
|
|
14
|
+
export const RE_OPT = /^[ \t]*([A-D])[.、))]\s*(\S.+)$/
|
|
15
|
+
// 作答:单字母或「我选 B / 选 C / 答案:D」形态
|
|
16
|
+
export const RE_ANS = /^\s*(?:我选|选|答案|答)\s*[::]?\s*([A-D])\s*[.。]?\s*$|^\s*([A-D])\s*[.。]?\s*$/
|
|
17
|
+
// 反馈:首个非空行以 ✅/❌ 开头,后跟 正确/错误/答对/答错(可省空格,后缀词可缺省)
|
|
18
|
+
export const RE_FB = /^\s*([✅❌])\s*(正确|错误|答对|答错)?/
|
|
19
|
+
|
|
20
|
+
/**
|
|
21
|
+
* 从 assistant 消息文本解析选择题;题号行 + ≥2 条连续选项行双条件,
|
|
22
|
+
* 任一不满足返回 null(消息按普通文本渲染,降级策略)。
|
|
23
|
+
*/
|
|
24
|
+
export function parseQuizQuestion(text) {
|
|
25
|
+
if (typeof text !== 'string' || !text.includes('题')) return null
|
|
26
|
+
const lines = text.split(/\r?\n/)
|
|
27
|
+
let head = -1
|
|
28
|
+
let headM = null
|
|
29
|
+
for (let i = 0; i < lines.length; i++) {
|
|
30
|
+
const m = RE_QHEAD.exec(lines[i])
|
|
31
|
+
if (m) { head = i; headM = m; break }
|
|
32
|
+
}
|
|
33
|
+
if (head === -1) return null
|
|
34
|
+
const stem = []
|
|
35
|
+
const options = []
|
|
36
|
+
let i = head + 1
|
|
37
|
+
// 题干:题号行与首个选项行之间的非空行
|
|
38
|
+
for (; i < lines.length; i++) {
|
|
39
|
+
if (RE_OPT.test(lines[i])) break
|
|
40
|
+
const t = lines[i].trim()
|
|
41
|
+
if (t) stem.push(t)
|
|
42
|
+
}
|
|
43
|
+
// 选项:连续选项行(允许中间空行),遇非选项非空行即止
|
|
44
|
+
for (; i < lines.length; i++) {
|
|
45
|
+
const line = lines[i]
|
|
46
|
+
if (!line.trim()) { if (options.length) continue; else continue }
|
|
47
|
+
const m = RE_OPT.exec(line)
|
|
48
|
+
if (!m) break
|
|
49
|
+
options.push({ key: m[1], text: m[2].trim() })
|
|
50
|
+
}
|
|
51
|
+
if (options.length < 2) return null
|
|
52
|
+
return {
|
|
53
|
+
index: Number(headM[1]),
|
|
54
|
+
total: Number(headM[2]),
|
|
55
|
+
node: (headM[3] || '').trim() || null,
|
|
56
|
+
stem: stem.join(' '),
|
|
57
|
+
options,
|
|
58
|
+
raw: text,
|
|
59
|
+
}
|
|
60
|
+
}
|
|
61
|
+
|
|
62
|
+
/** 用户消息是否是一次作答;命中返回字母,否则 null */
|
|
63
|
+
export function matchAnswer(text) {
|
|
64
|
+
if (typeof text !== 'string') return null
|
|
65
|
+
const m = RE_ANS.exec(text.trim())
|
|
66
|
+
if (!m) return null
|
|
67
|
+
return m[1] || m[2] || null
|
|
68
|
+
}
|
|
69
|
+
|
|
70
|
+
/** assistant 消息首行是否是判分反馈;命中返回 { correct, text },否则 null */
|
|
71
|
+
export function matchFeedback(text) {
|
|
72
|
+
if (typeof text !== 'string') return null
|
|
73
|
+
const firstLine = text.split(/\r?\n/).find(l => l.trim())
|
|
74
|
+
if (!firstLine) return null
|
|
75
|
+
const m = RE_FB.exec(firstLine)
|
|
76
|
+
if (!m) return null
|
|
77
|
+
return { correct: m[1] === '✅', text: text.trim() }
|
|
78
|
+
}
|
|
79
|
+
|
|
80
|
+
/**
|
|
81
|
+
* 「题→答→反馈」配对状态机(纯函数,无副作用):
|
|
82
|
+
* 顺序扫描(按 seq 升序)映射后的消息,闭环三元组收集进 triples,
|
|
83
|
+
* 题目消息附 m.quiz 结构化标注(state=pending/answered/graded)。
|
|
84
|
+
* 返回 { messages, triples };messages 是浅拷贝数组,原数组不动。
|
|
85
|
+
*/
|
|
86
|
+
export function annotateQuiz(messages) {
|
|
87
|
+
const list = (messages || []).slice().sort((a, b) => (a.seq || 0) - (b.seq || 0))
|
|
88
|
+
const out = new Array(list.length)
|
|
89
|
+
let pending = null // { qMsg, idx, ans, ansSeq, ansText }
|
|
90
|
+
const triples = []
|
|
91
|
+
for (let i = 0; i < list.length; i++) {
|
|
92
|
+
const m = list[i]
|
|
93
|
+
if (m.role === 'assistant') {
|
|
94
|
+
const q = parseQuizQuestion(m.text)
|
|
95
|
+
if (q) {
|
|
96
|
+
// quiz 规则一次一题;新题出现时旧 pending 未闭环直接丢弃,不落盘
|
|
97
|
+
pending = { qMsg: m, idx: i, q, ans: null, ansSeq: null, ansText: null }
|
|
98
|
+
out[i] = { ...m, quiz: { ...q, state: 'pending', answer: null, correct: null } }
|
|
99
|
+
continue
|
|
100
|
+
}
|
|
101
|
+
if (pending && pending.ans) {
|
|
102
|
+
const fb = matchFeedback(m.text)
|
|
103
|
+
if (fb) {
|
|
104
|
+
// 三元组闭环
|
|
105
|
+
const quiz = out[pending.idx].quiz
|
|
106
|
+
quiz.state = 'graded'
|
|
107
|
+
quiz.answer = pending.ans
|
|
108
|
+
quiz.correct = fb.correct
|
|
109
|
+
triples.push({
|
|
110
|
+
q: pending.q, fbSeq: m.seq, fbText: fb.text, correct: fb.correct,
|
|
111
|
+
answer: pending.ans, answerSeq: pending.ansSeq, answerText: pending.ansText,
|
|
112
|
+
})
|
|
113
|
+
pending = null
|
|
114
|
+
}
|
|
115
|
+
}
|
|
116
|
+
} else if (m.role === 'user' && pending) {
|
|
117
|
+
const letter = matchAnswer(m.text)
|
|
118
|
+
if (letter) {
|
|
119
|
+
pending.ans = letter
|
|
120
|
+
pending.ansSeq = m.seq
|
|
121
|
+
pending.ansText = m.text
|
|
122
|
+
const quiz = out[pending.idx].quiz
|
|
123
|
+
if (quiz) { quiz.state = 'answered'; quiz.answer = letter }
|
|
124
|
+
}
|
|
125
|
+
// 非字母消息视为插入对话,pending 保持
|
|
126
|
+
}
|
|
127
|
+
if (out[i] === undefined) out[i] = m
|
|
128
|
+
}
|
|
129
|
+
return { messages: out, triples }
|
|
130
|
+
}
|
|
131
|
+
|
|
132
|
+
// ── 幂等落盘(路由层调用,唯一带副作用的部分) ─────────────────────
|
|
133
|
+
|
|
134
|
+
const FB_MARK = /<!--\s*quiz:fbSeq=(\d+)\s*-->/g
|
|
135
|
+
|
|
136
|
+
function quizFiles(root, topic) {
|
|
137
|
+
const dir = path.join(root, 'curriculum', topic)
|
|
138
|
+
return { dir, log: path.join(dir, 'quiz.md'), state: path.join(dir, 'quiz-state.json') }
|
|
139
|
+
}
|
|
140
|
+
|
|
141
|
+
/**
|
|
142
|
+
* 水位:取 quiz-state.json 与 quiz.md 最后 fbSeq 标记的较大者(双保险)。
|
|
143
|
+
* append 成功后写水位文件失败/崩溃时,状态文件会落后于 quiz.md 内标记,
|
|
144
|
+
* 无条件取 max 才能挡住重复追加(文件内标记去重是设计的兜底承诺)。
|
|
145
|
+
*/
|
|
146
|
+
export async function readWatermark(root, topic) {
|
|
147
|
+
const { log, state } = quizFiles(root, topic)
|
|
148
|
+
let fromState = -1
|
|
149
|
+
try {
|
|
150
|
+
const j = JSON.parse(await readFile(state, 'utf8'))
|
|
151
|
+
if (typeof j.feedbackSeq === 'number') fromState = j.feedbackSeq
|
|
152
|
+
} catch { /* 损坏/缺失,视为 -1 */ }
|
|
153
|
+
let fromLog = -1
|
|
154
|
+
try {
|
|
155
|
+
const text = await readFile(log, 'utf8')
|
|
156
|
+
for (const m of text.matchAll(FB_MARK)) fromLog = Math.max(fromLog, Number(m[1]))
|
|
157
|
+
} catch { /* 无 quiz.md,视为 -1 */ }
|
|
158
|
+
return Math.max(fromState, fromLog)
|
|
159
|
+
}
|
|
160
|
+
|
|
161
|
+
function formatRecord(t, date) {
|
|
162
|
+
const opts = t.q.options.map(o => `${o.key}. ${o.text}`).join(' | ')
|
|
163
|
+
const ansOpt = t.q.options.find(o => o.key === t.answer)
|
|
164
|
+
return `\n## ${date} · 第 ${t.q.index} / ${t.q.total} 题 · ${t.q.node || '-'} ${t.correct ? '✅' : '❌'}\n` +
|
|
165
|
+
`- 题面:${t.q.stem}\n` +
|
|
166
|
+
`- 选项:${opts}\n` +
|
|
167
|
+
`- 所答:${t.answer}${ansOpt ? `(${ansOpt.text})` : ''}\n` +
|
|
168
|
+
`- 反馈:${t.fbText.split(/\r?\n/)[0]}\n` +
|
|
169
|
+
`<!-- quiz:fbSeq=${t.fbSeq} -->\n`
|
|
170
|
+
}
|
|
171
|
+
|
|
172
|
+
/**
|
|
173
|
+
* 追加一条闭环三元组到 quiz.md(幂等:fbSeq ≤ 水位直接跳过)。
|
|
174
|
+
* 写入顺序:先 append quiz.md(标记在内),成功后更新水位文件。
|
|
175
|
+
* 失败抛错由调用方捕获(路由层只 console.warn,不阻断响应)。
|
|
176
|
+
*/
|
|
177
|
+
export async function appendQuizLog(root, topic, triple, today) {
|
|
178
|
+
const { dir, log, state } = quizFiles(root, topic)
|
|
179
|
+
const watermark = await readWatermark(root, topic)
|
|
180
|
+
if (!(triple.fbSeq > watermark)) return false
|
|
181
|
+
const date = today || new Date().toISOString().slice(0, 10)
|
|
182
|
+
await mkdir(dir, { recursive: true })
|
|
183
|
+
let header = ''
|
|
184
|
+
try { await readFile(log, 'utf8') } catch { header = `# 答题记录 · ${topic}\n` }
|
|
185
|
+
await appendFile(log, header + formatRecord(triple, date), 'utf8')
|
|
186
|
+
await writeFile(state, JSON.stringify({ feedbackSeq: triple.fbSeq }), 'utf8')
|
|
187
|
+
return true
|
|
188
|
+
}
|
|
189
|
+
|
|
190
|
+
/** quiz.md → 记录数组(倒序,最新在前);无文件返回 [] */
|
|
191
|
+
export async function parseQuizLog(root, topic) {
|
|
192
|
+
const { log } = quizFiles(root, topic)
|
|
193
|
+
let text = ''
|
|
194
|
+
try { text = await readFile(log, 'utf8') } catch { return [] }
|
|
195
|
+
const records = []
|
|
196
|
+
const blocks = text.split(/(?=^## )/m)
|
|
197
|
+
for (const b of blocks) {
|
|
198
|
+
const mark = [...b.matchAll(FB_MARK)].pop()
|
|
199
|
+
const head = /^## (\d{4}-\d{2}-\d{2}) · 第 (\d+) \/ (\d+) 题 · (.*?) (✅|❌)\s*$/m.exec(b)
|
|
200
|
+
if (!head || !mark) continue
|
|
201
|
+
const pick = (re) => { const m = re.exec(b); return m ? m[1].trim() : '' }
|
|
202
|
+
const answerM = /^- 所答:([A-D])(?:((.*)))?$/m.exec(b)
|
|
203
|
+
records.push({
|
|
204
|
+
date: head[1],
|
|
205
|
+
index: Number(head[2]),
|
|
206
|
+
total: Number(head[3]),
|
|
207
|
+
node: head[4] === '-' ? null : head[4],
|
|
208
|
+
correct: head[5] === '✅',
|
|
209
|
+
stem: pick(/^- 题面:(.*)$/m),
|
|
210
|
+
options: pick(/^- 选项:(.*)$/m),
|
|
211
|
+
answer: answerM ? answerM[1] : '',
|
|
212
|
+
answerText: answerM && answerM[2] ? answerM[2] : '',
|
|
213
|
+
feedback: pick(/^- 反馈:(.*)$/m),
|
|
214
|
+
fbSeq: Number(mark[1]),
|
|
215
|
+
})
|
|
216
|
+
}
|
|
217
|
+
return records.reverse()
|
|
218
|
+
}
|
|
@@ -0,0 +1,37 @@
|
|
|
1
|
+
# quiz — 出题规范
|
|
2
|
+
|
|
3
|
+
任何需要"做题"的场合:probe 阶段定位水平、教学中的节点确认、错题复习。配合 teach skill 使用。
|
|
4
|
+
|
|
5
|
+
## 聊天内固定格式
|
|
6
|
+
|
|
7
|
+
```
|
|
8
|
+
**第 2 / 5 题 · 离散采样**
|
|
9
|
+
|
|
10
|
+
以采样率 $f_s$ 对信号采样,能无失真恢复的最高信号频率是?
|
|
11
|
+
|
|
12
|
+
A. $f_s$
|
|
13
|
+
B. $\dfrac{f_s}{2}$
|
|
14
|
+
C. $2f_s$
|
|
15
|
+
D. $\dfrac{f_s}{4}$
|
|
16
|
+
```
|
|
17
|
+
|
|
18
|
+
用户答一个字母(如 `B`),立刻反馈,然后再下一题:
|
|
19
|
+
|
|
20
|
+
```
|
|
21
|
+
✅ 正确 —— 奈奎斯特定理:恢复需要每个周期至少两个采样点,所以上限是采样率的一半。
|
|
22
|
+
```
|
|
23
|
+
|
|
24
|
+
## 规则
|
|
25
|
+
|
|
26
|
+
1. **选项裸列**:任何选项都不带"为什么",所有推理放在反馈里,答题后才出现。数字选项尤其注意,给正确项加理由等于标星号。
|
|
27
|
+
2. **干扰项靠构造**:先写正确断言,再各取一个具体误解(无心之失 / 孤立记忆 / 概念混淆),问"持这个误解的人会怎么答",以同样骨架写出来。
|
|
28
|
+
3. **每个干扰项都要有诊断价值**:是他可能真犯的错,但在预期解读上明确错。不玩文字游戏。
|
|
29
|
+
4. **不做非对称加粗/强调**:要么都不强调,要么每项强调平行的术语。
|
|
30
|
+
5. **即时反馈**:答对答错都要给一句"为什么";答错时同时指出这暴露的是哪类误解(要进错题本的依据)。
|
|
31
|
+
6. **一次一题**,答完再出下一题;probe 阶段按二分策略跳难度(对→大幅加难,错→收窄定性)。
|
|
32
|
+
7. 数学记号一律 LaTeX,与正文渲染一致。
|
|
33
|
+
8. **边界探测逻辑**(probe 专用):全对不算会,继续加难度直到出错;单个错不急于定性,在它周围再探一两题区分误解类型。
|
|
34
|
+
|
|
35
|
+
## 无对错答案的问题不用 quiz
|
|
36
|
+
|
|
37
|
+
偏好、方向、"你接下来想学什么"这类问题用 ask_user_question,不要伪装成选择题。
|
|
@@ -0,0 +1,165 @@
|
|
|
1
|
+
# teach — 教学
|
|
2
|
+
|
|
3
|
+
教用户任何东西,目标是**理解**而非记住。适用于任何解释或教学的场合。基于两条经多年个人验证的教学原则。
|
|
4
|
+
|
|
5
|
+
---
|
|
6
|
+
|
|
7
|
+
# 教学法
|
|
8
|
+
|
|
9
|
+
两条原则。它们不是技巧,而是每次教学的方式。没有其他教学法能与之相比。适用于任何长度的解释,从一句话到深潜。
|
|
10
|
+
|
|
11
|
+
目标从来不是"他能复述事实",目标是**理解**:事实可以从他已接受的基础推导出来,连进他的心智模型,从而自我推演。记住的事实会腐烂,理解的事实不会。
|
|
12
|
+
|
|
13
|
+
## 哲学(为什么要这样 —— 内化它)
|
|
14
|
+
|
|
15
|
+
两个人的大脑可以持有相同的一堆命题,从外面看起来一模一样(对同样的问题给出同样的答案)。但一个人的是一堆**互不相连的孤立事实**(A),另一个人的是少数**核心真理**,所有那些事实都能从中推导出来(B),所以在他看来那些事实是显而易见地连接着的。那个连接**就是**理解。
|
|
16
|
+
|
|
17
|
+
- 连接的知识 > 孤立的知识
|
|
18
|
+
- 依赖关系图 > 孤立的节点
|
|
19
|
+
- 理解 > 死记
|
|
20
|
+
|
|
21
|
+
理解让知识保持(靠连接钉住)、压缩它、并且 plainly 更好。每次教学都在帮学习者在他脑中建立那张依赖图:**节点**(原则 i)和**边**(原则 ii)。
|
|
22
|
+
|
|
23
|
+
终极体验是**咔哒声**:一堆孤立事实坍缩(压缩)成少数几个生成性想法的那一刻——同样的信息,远少于原来的活动部件。教得好的时候,那就是学习它从内部的感觉;瞄准它。
|
|
24
|
+
|
|
25
|
+
关键机制:**大脑不会完全接受一个它不确定是否安全的事实。** 如果某个更基础的东西日后可能与之矛盾,接受它就是有风险的——那会迫使一次昂贵的更新。所以大脑会犹豫,事实永远不会真正落地。两条原则都在消除这个风险。
|
|
26
|
+
|
|
27
|
+
## 原则 i —— 无条件真理优先
|
|
28
|
+
|
|
29
|
+
从地面开始。先锁定核心的、**永远为真**的无条件真理,再在它们之上建立任何东西。
|
|
30
|
+
|
|
31
|
+
为什么从这里开始?**不是**因为自底向上是逻辑上"正确"的顺序——而是因为无条件真理是大脑最容易接受并锁定的东西。它们是安全的,所以立刻提交;并且它们给了第一个坚实的地面去站立和构建。在主题完全新、几乎没什么可连接的时候尤其有价值。
|
|
32
|
+
|
|
33
|
+
**术语 —— 保持区分,不要滥用"公理"。** 一个*无条件真理*是一个他可以**照单全收、按面值、不带条件或细微差别**接受的事实——这是*事实如何被持有*的属性。一个*公理*是一个*不依赖其他任何东西*的事实——这是*它在图中的位置*的属性(一个没有入边的根节点)。它们有重叠但不等同:一个同时也是免细微差别的公理是无条件真理的一种,但很多无条件真理*确实*是从更深的东西推导出来的——它们只是不需要那层推导就可以安全地接受。默认说**"无条件真理"**;保留**"公理"**给真正从底部生成的事实。不要因为某件事听起来基础就叫它公理。
|
|
34
|
+
|
|
35
|
+
- 找出他能按面值接受的少数硬事实——往往是第一性原理,虽然它们不需要是真根。可能很少。没关系;小而坚实的节拍优于大而松散的。
|
|
36
|
+
- 它们必须简单到能被**照单全收、不带细微差别或条件**地接受。没有"嗯,通常……"。如果需要条件,它还不是无条件真理——继续往下挖。
|
|
37
|
+
- 这些可以**立刻且安全地**提交,因为不会有更基础的东西来反驳它们。那份安全就是让它们锁定的东西。
|
|
38
|
+
- 其他一切都从这些显式地向上构建,这样他能看到每个新事实立在地面之上。
|
|
39
|
+
|
|
40
|
+
**在建立之前确认地面。** 简短地检查每个核心真理对他来说是否真的读起来是显然/无条件地真,然后再在上面加结构。如果一个核心真理感觉不扎实,停下来修地面——不要在沙地上建。
|
|
41
|
+
|
|
42
|
+
**两种特别强的无条件真理形式,优先找:**
|
|
43
|
+
- **全称陈述** —— "所有 X 都是 Y"或"没有 X 是 Y"。大脑容易锁定因为它们不容许例外。一个干净的原子的-单元版本("**所有** X 都是通过 {______} 完成的",比如"所有计算机之间的通信都是通过 {发送数据包} 完成的")是一个特别强的特例——当一个领域有一个时就浮现它,但它只是全称陈述的一种形状,不是唯一的一种。
|
|
44
|
+
- **真实定义** —— 一个属加种差定义是伟大的起点。但只当它是一个*真实的*定义,不是一堆属性凑成的一个伪装的列表。如果只是"倾向于 X 为真的东西",它不是定义,锚不住任何东西。
|
|
45
|
+
|
|
46
|
+
不存在干净的一个时,不要硬凑。
|
|
47
|
+
|
|
48
|
+
## 原则 ii —— "我怎么可能自己发现这个?"
|
|
49
|
+
|
|
50
|
+
当事实没有可见的*原因*说明它们**不得不**是这样时,会感觉武断。"为什么它需要是这样?感觉武断。"大脑不会提交给感觉武断的信息。修正:让它感觉被发现的,而不是被宣告的。
|
|
51
|
+
|
|
52
|
+
带他走一遍他**自己怎么可能发现这个东西**。每一步都必须有*动机*:
|
|
53
|
+
|
|
54
|
+
- 从方格一开始:**我们为什么在做这件事?** 什么核心问题把我们送上了这条路?
|
|
55
|
+
- 给每个中间步骤也带上动机:为什么要试*这个*公式?为什么*这样*操作方程?什么可能让人走到这条路上来?
|
|
56
|
+
- 产出是把**不连接的命题 → 连接的命题**——把边加进图里。
|
|
57
|
+
|
|
58
|
+
3Blue1Brown(Grant Sanderson)是这方面的宗师参考。瞄准那个:没有东西凭空出现;每一步都感觉像是学习者自己可能到达的。
|
|
59
|
+
|
|
60
|
+
## 苏格拉底式 vs 讲解式 —— 自适应
|
|
61
|
+
|
|
62
|
+
按每个主题和学习者的当下精力选择。
|
|
63
|
+
- **苏格拉底式** —— 先抛出有动机的问题让他自己尝试发现,再揭示。更费劲、更强的锁定。当他能 plausible 地推理自己的路线时默认这个。"让他试一下"是关于*谁先说话*,不是关于评分:如果你问的问题有确定的对错答案(哪怕是一个他自由回答的开式提示,你然后改写成选择题),它仍然可判分——用 quiz,不是 ask_user_question。把 ask_user_question 留给真正无对错答案的分叉(偏好、方向、他接下来想要什么)。
|
|
64
|
+
- **讲解式** —— 你自己走完有动机的发现路径(3B1B 风格),不需要来回。用在主题超出冷的推理能到达的范围,或者他低精力/想要被投喂时。
|
|
65
|
+
|
|
66
|
+
不确定时,倾向苏格拉底式,用于他能清楚推理的事情;否则讲解式。
|
|
67
|
+
|
|
68
|
+
# 主题与资料来源(学习空间的入口)
|
|
69
|
+
|
|
70
|
+
学什么永远由用户决定。开始一节新的学习会话时:
|
|
71
|
+
|
|
72
|
+
1. **先问主题和学习目标**(用 ask_user_question 或直接问):"这节课想学什么?想达到什么程度?"目标没说清楚就继续追问,直到具体。
|
|
73
|
+
2. **资料来源二选一或组合,问用户要哪种:**
|
|
74
|
+
- **用户自带资料** —— 检查 `materials/<topic>/` 目录下是否有用户上传的文件(PDF/Markdown/代码/随便什么)。有就以它为主要教学依据,读原文再规划。
|
|
75
|
+
- **上网获取** —— 没有本地资料时,派 researcher 子代理(或自己 web_search)扫一遍主题:核心概念、第一性原理、标准框架、常见误区。**拿不准的事实先核查再教**,绝不硬编。
|
|
76
|
+
3. 资料齐了才进 Phase 2 规划。用户上传的资料优先于网络检索结果。
|
|
77
|
+
|
|
78
|
+
# 流程:probe → plan → teach
|
|
79
|
+
|
|
80
|
+
两条原则是*怎么教*。这个是*什么时候*——一节教学课的形状。三个阶段按顺序跑,每次都是;每个阶段的*规模*适配主题,永远不改*形状*。
|
|
81
|
+
|
|
82
|
+
**准确性不可协商 —— 去核实,别凭记忆编。** 他必须能完全信任老师;一次自信满满的胡编就毒化那份信任。只凭记忆写东西正是 LLM 编造东西的地方,所以:**当你对任何事实、名字、日期、公式、定义或说法有一丝不确定时,停下来派一个快速 researcher 子代理先核实再说。** 暂停核实永远可以接受——准确性胜过流畅。如果一个核查挑战或纠正了你正要教的东西,直说而不是悄悄绕过。一个错误的无条件真理或错误的"被发现"步骤不只是误导——它污染每个建在它上面的节点。
|
|
83
|
+
|
|
84
|
+
## 写 quiz 选项 —— 一个构造程序(适用于每次 quiz)
|
|
85
|
+
|
|
86
|
+
先写好答案加几个错误项,不要事后重新斟酌。在跑任何检查前把整套写完,别做事后审计。
|
|
87
|
+
|
|
88
|
+
1. **每个选项都是一个裸断言 —— 没有任何"为什么"。** 数字选项给答案那个带上理由(",因为它保留了 X")而干扰项光秃秃,等于把正确选项标了星号。任何选项里都放**零**个"为什么";所有推理放进 `解析` 字段,那只在答题后才出现。
|
|
89
|
+
2. **先写正确断言,再把它变形出每个干扰项。** 取一个具体的误解或容易混淆的邻近概念,问"持这个误解的人会怎么答这道题",以*同样的骨架、同样的粒度*写出来,登记为错误项。现在每个选项都是"某个信念下的答案",正确的那个只是*正确*信念下的答案。平行结构靠构造产生,而不是靠润色。
|
|
90
|
+
3. 每个干扰项仍须是他可能真犯的错误(这样选哪个才具诊断性),但在预期解读上**不含糊地错**——考理解,不玩文字游戏。
|
|
91
|
+
4. **不做非对称加粗。** 别把关键概念只加粗在一个选项里。要么都不加粗,要么每个选项里加粗平行的术语。
|
|
92
|
+
|
|
93
|
+
如果读完写完的整套选项你不用看材料都能挑出对的,说明跳过了第 1 或 2 步——重造,别打补丁。
|
|
94
|
+
|
|
95
|
+
## Phase 1 —— Probe(永远别跳过)
|
|
96
|
+
|
|
97
|
+
不摸清理解的边界就没法教学,也瞄准不了教学。两个独立的未知数,两个独立的工具——边界要分清:
|
|
98
|
+
|
|
99
|
+
**1a. 他当下的水平 —— 用 quiz。** 这是测绘,不是抽查。目标是定位他理解的*边界*——前端:他可靠知道的止步于哪里,后面计划的每节课都依赖它。在实际找到边界之前别往前走,这个阶段要多长有多长、要多细有多细。没有 rush。
|
|
100
|
+
|
|
101
|
+
- **边界只在被撞破时才算找到。** 对每条相关线索你需要*两*样:这个水平上他**对**的什么(一个地板——证明他至少知道这么多),和他**错的**或真的不知道的什么(一个天花板——他的理解在这里断掉)。边界坐落其间。单侧线索几乎不说明问题。
|
|
102
|
+
- **全对不等于"会了"——只说明题太简单了。** 一轮全对给你一个没有天花板的 地板:你知道他至少懂这么多,但对他的知识在哪里结束一无所获。别推进。加难度直到有东西终于破掉。他从不失手,你就永远没找到边界。
|
|
103
|
+
- **二分搜索边界。** 他答对就*大幅*跳难——别小步加。他失手了,你已经从上方把边界撞破;收窄回来精确定位它。这样最快找到前端,不用冗长的计时题。
|
|
104
|
+
- **答错一题也不等于"找到边界可以开教了"——而且它*不是*开始教的借口。** 单个失手只是一个坐标,你还不知道它的类型:一次无心之失、一个窄的孤立缺口,还是一个系统性的误解。先在它*周围*探查把它定性再下结论。误解最要紧——一个自信持有的错误模型必须被拆掉而不是被绕过,所以抓到一个时,挖进它的范围而不是走开。
|
|
105
|
+
- **映射这节课依赖的每一条线索。** 一个主题有几条前置线,边界是横跨它们的前沿,不是一个点。探查每条线的解释从哪里断掉。靠*对目标的相关性*来界定:映射每一条教学将依赖的线,不相关的角落别管。
|
|
106
|
+
|
|
107
|
+
**1b. 他的学习目标 —— 用 ask_user_question。** 搞清楚他到底想被教会什么。对一个他不了解的主题,目标往往难以自己表述——"我想理解 LLM"或"互联网怎么工作"可能意味着完全不同的东西,哪个完全改变你要教什么。追问愿景直到具体。这没有对错答案,所以是 `ask_user_question`,永远不是 quiz。
|
|
108
|
+
|
|
109
|
+
## Phase 2 —— Plan(在这里使劲想)
|
|
110
|
+
|
|
111
|
+
这是杠杆最高的步骤,别赶。手里有了他的水平和目标,停下来真正想清楚教*这个东西*给*这个人*的最好方式。对照上面的哲学重新读一遍再规划:
|
|
112
|
+
|
|
113
|
+
- **先用 researcher 子代理扫一遍领域。** 规划图之前,快速派 researcher 扫主题——核心概念、真正的第一性原理、标准框架、常见误区。这既刷新你对主题的把握,也浮出那些正经的无条件真理,免得围绕一个凭记忆的半吊子版本规划。花得值,还让整个计划更准。
|
|
114
|
+
- 这个主题的**无条件真理**是哪些?有没有一个干净的原子单元("所有 X 都是通过 {______} 完成的")?
|
|
115
|
+
- 那些里面他**已经**持有哪些(Phase 1a 的结果)?从那里建——别低于它,别高于它。
|
|
116
|
+
- 从那些真理到他的目标,有动机的发现路径是什么?每一步从哪来——为什么有人会伸手去够它?
|
|
117
|
+
- 每段用苏格拉底式还是讲解式,给定主题和他的精力?
|
|
118
|
+
|
|
119
|
+
一个好计划让教学感觉必然而不是武断。
|
|
120
|
+
|
|
121
|
+
**然后在聊天里展示计划 —— 永远先于教学。** 两部分:
|
|
122
|
+
|
|
123
|
+
1. **方法,用 prose。** 我们会覆盖什么、以什么顺序、为什么这样走,给出他的边界位置(1a)和他要达到的目标(1b)。几句话。
|
|
124
|
+
2. **依赖图。** 计划的骨架是一张 DAG:无条件真理做根,每个派生节点挂着它依赖什么,他的目标做汇点。用一个小 mermaid 图画出来。这张图*就是*教学顺序——Phase 3 逐节点构建它。保持小:几个节点、短标签——是地图,不是领土。
|
|
125
|
+
|
|
126
|
+
**展示之前先压力测试根节点。** 对每个你打算当地基的节点,问:这对他来说真的无条件为真吗,还是一个本身从更简单的他会照单全收的东西推导出来的化了妆的定理?如果可以推导,推下去并延伸地图——永远别把课建在一个中层事实上。错的根节点污染挂在它上面的一切,而根在草稿图里远比在教学中途好审计。
|
|
127
|
+
|
|
128
|
+
**然后停下来等他点头。** 展示的计划是他的检查点:错的根或错的 scope 现在修便宜,课中修昂贵。他没批准之前别开始 Phase 3。
|
|
129
|
+
|
|
130
|
+
## Phase 3 —— Teach(循环)
|
|
131
|
+
|
|
132
|
+
一次建依赖图上的**一个节点**——每个节点受到同等的对待,不管它是地基性的无条件真理还是派生步骤。几乎从不止一个;多数主题要好几个,每个新节点走过和任何其他节点完全一样的循环:
|
|
133
|
+
|
|
134
|
+
对**每个节点**(每条无条件真理*和*每个朝向目标的非平凡推理步骤),跑:
|
|
135
|
+
|
|
136
|
+
1. **Motivate(动机)。** 框定为什么我们现在需要这个节点——它解决什么问题或合上什么缺口。对无条件真理也一样:别因为它真就直接断言,motivate 为什么*这个*真理,为什么是现在。"我们为什么一开始要管这个?"
|
|
137
|
+
2. **Establish(建立)。**
|
|
138
|
+
- 如果是地基性的无条件真理:直陈、按面值、无细微差别。如果存在的话浮现一个原子单元。
|
|
139
|
+
- 如果是派生步骤:从已建立的东西经由一次有动机的移动(苏格拉底式或讲解式)构建,回答"我怎么可能自己发现这个?"。当苏格拉底式步骤有可判分的对/错答案时用 quiz 提问,即便他正在"尝试发现"——可判分且苏格拉底式是正常的不冲突;只有真正无对错答案的分叉才落回 ask_user_question。
|
|
140
|
+
3. **Connect(连接)。** 把依赖的边显式化——展示这个新节点如何精确地挂在那些已在位的节点上,这样它是被理解的,不是被记住的。
|
|
141
|
+
4. **Quiz-check(测验确认)。** 用一个快速 quiz 确认节点真正落地——地基和派生步骤同样要。一个未确认的无条件真理和一个未确认的派生事实同样危险:如果他失手,那个节点就不坚实,停下来在往上建之前先修它。
|
|
142
|
+
|
|
143
|
+
每个节点重复这个完整循环——别在最前面一次性预加载所有地基然后停止检查。教学进行中需要新的无条件真理时,它像任何派生步骤一样走 Motivate → Establish → Connect → Quiz-check。
|
|
144
|
+
|
|
145
|
+
如果你发现自己在断言一个你得赌上信心的事实——地基性的与否——停下来:要么 motivate 它并确认它落地,要么把它磨进已建立的东西里。没有动机、没有确认的事实不会锁定——那才是重点所在。
|
|
146
|
+
|
|
147
|
+
## 排版 —— 数学用 LaTeX
|
|
148
|
+
|
|
149
|
+
凡是涉及数学记号的地方——解释、问题、quiz 选项和解析——写 LaTeX 而不是纯文本近似:
|
|
150
|
+
|
|
151
|
+
- 行内公式:`$f(x)$`
|
|
152
|
+
- 独立成行的公式:`$$` 各占一行,例如 `$$\n f(x) = x^2\n $$`
|
|
153
|
+
|
|
154
|
+
能用 LaTeX 就用。写 $f(x) = x^2$,不是 `f(x) = x^2`。
|
|
155
|
+
|
|
156
|
+
# 学习空间的课后沉淀(硬性约定)
|
|
157
|
+
|
|
158
|
+
一节课结束(或一个节点确认后),必须更新学习空间的数据文件,UI 面板靠它们渲染:
|
|
159
|
+
|
|
160
|
+
1. `curriculum/<topic>/plan.md` —— 依赖图 mermaid + 节点状态(`[x]` 已确认 / `[~]` 进行中 / `[!]` 有错题待修 / `[ ]` 未学),按本文档 Phase 2 的 DAG 格式维护;
|
|
161
|
+
2. `curriculum/<topic>/notes/<node>.md` —— 每个已确认节点一篇笔记,frontmatter 带 `node:`、`deps:`、`date:`;
|
|
162
|
+
3. `curriculum/<topic>/mistakes.md` —— 答错的题:原题、他的答案、误解类型(粗心/孤立记忆/概念混淆)、正确解析;
|
|
163
|
+
4. `journal/YYYY-MM.md` —— 当月文件追加一行:日期、主题、节点、一句摘要。
|
|
164
|
+
|
|
165
|
+
新主题第一次创建时,先建 `curriculum/<topic/` 目录和 plan.md 骨架,用户资料放 `materials/<topic>/`。
|