acmer-coach 2.4.0 → 2.5.0

package/README.md

@@ -20,7 +20,7 @@
 
 ## 它到底做了什么
 
-30 个工具，三条轴：知识图、比赛能力、训练证据。
+31 个工具，三条轴：知识图、比赛能力、训练证据。
 
 | 轴 | 含义 |
 |---|---|
@@ -49,6 +49,7 @@ coach_schedule → coach_plan              排课
 coach_target → coach_vp_import → coach_postmortem → coach_focus
   ↓                         比赛目标、VP 复盘、当前重点
 coach_scope                  适用范围、延伸、反例、退出条件
+coach_note                   续课笔记：教到哪里、尚待确认什么、下次接哪里
 ```
 
 `coach_wiki` 是知识来源：讲任何知识点之前先查本地 OI Wiki，**别凭记忆讲**。
@@ -72,6 +73,9 @@ VP 记录格式是 JSON 数组，每场至少包含 `eventId`、`contest`、`dat
 `coach_scope` 会返回一个能力或知识点的适用范围、延伸、反例、常见错误、迁移题
 和退出条件。没有人工范围卡片时它会明确拒绝编造，避免把“讲过”误当成“会用”。
 
+能力排名只是取舍参考。排在前三之外、尚未映射到目标能力的节点也能布置，由小鲸解释
+为什么现在练；课程版本、当前阶段和真实前置的检查继续保留。
+
 ### 长期学习路线
 
 `coach_curriculum assess` 从已有检测、代码判因、做题记录和日程实际完成中列出
@@ -117,6 +121,24 @@ learned/verified 记录，或路线中在此前安排的必验训练，不能从
 
 详见 [长期课程机制](docs/长期课程机制.md)。
 
+### 2.5：接着教，判断仍归小鲸
+
+`coach_note` 只做一件事：把一个知识点的教学判断和接续点留在现有
+`PROGRESS.yaml` 的 `nodes.<id>.lessonNotes`。`read` 查看最近笔记，`write` 保存
+`summary` 与 `nextStep`；不新增课程状态机、聊天数据库或另一份掌握记录。
+`coach_status` 的 `teachingContext` 和每轮首步状态会带上短笔记，需要原话时再查原生会话。
+未指定节点时，读取优先显示最近有笔记的未完动作，再看游标；没有游标则看最近笔记。
+写入默认使用游标，显式 `node` 优先，不会为了写笔记移动游标。
+
+`studentQuote` 可选。填写时核对当前 dsh 会话中的真实学生消息，自动记录来源；
+插件消息、压缩摘要和其他会话不能冒充学生回答。核对原话存在不等于判断学生理解，
+没有原话的笔记也可保存，但标作教练判断。笔记不会改进度状态、游标、待办或检测结果。
+旧宿主没有原生会话查询时，普通笔记可用，带原话的写入会明确拒绝。
+
+`teachMinutes` 现在只保存讲授计划，不再自动写“已经教过”的日期。实际进入学习由
+教练显式 `coach_mark studying` 记录；已有接触记录继续可用，但不证明理解。
+这版验证的是记录、来源和续课机制；真实小鲸对话的教学效果仍需观察。
+
 ### 2.4：证据、验收与教学依据
 
 `coach_focus` 分开近30天的独立成功、待确认观察、已确认短板，按不同场次计数。
@@ -250,11 +272,12 @@ dsh 的会话上下文有限 —— 新开一个会话，教练不记得上次
 
 | 文件 | 作用 |
 |---|---|
-| `index.js` | 插件本体（host 端，21 个工具 + 规则注入） |
+| `index.js` | 插件本体（host 端，31 个工具 + 规则注入） |
 | `lib/setup.js` | 环境搭建 + CF 公开数据同步 |
 | `lib/curriculum.js` | 持久课程路线、阶段验收门槛、版本与修订历史 |
 | `lib/curriculum-evidence.js` | 从实际记录派生证据引用与事件身份，去重课表和训练记录 |
 | `lib/curriculum-planning.js` | 阶段编排依据、前置顺序与进入阶段后的新证据检查 |
+| `lib/teaching.js` | 节点续课笔记，复用进度文件与 dsh 原生会话查询 |
 | `lib/client.js` | 浏览器端：会话头部「技能树」按钮 + 弹层 |
 | `package.json` | 声明 `dsh.bundle.patch` + `dsh.client` |
 | `cordis.patch.yml` | bundle 层的 insert 行 |
@@ -276,7 +299,7 @@ dsh 的会话上下文有限 —— 新开一个会话，教练不记得上次
 |---|---|---|
 | **规则** | `assets/rules/coach-rules.md` | 插件用 `systemPrompt.section()` 注进 system prompt（和人设同一条路）。**改它要重启 dsh** |
 | **知识** | 地图 4 份 + OI Wiki 检索库 | `coach_setup init` 铺到数据目录；OI Wiki 直接从包里读 |
-| **工具** | 21 个 | 装完就在 |
+| **工具** | 31 个 | 装完就在 |
 
 规则进的是 **system prompt，不是消息流**：行为约束每轮都得在场，
 而消息流会被长对话把尾巴挤掉。文本是**静态**的（只在加载时读一次）——

package/assets/rules/coach-rules.md

@@ -22,7 +22,9 @@
 * `coach_focus` 只汇总近30天不同场次：成功起点不算问题，重复提交/复盘不增加场次数，
   修改旧复盘不把它变成最近发生。分数是取舍参考，不是掌握度、出题概率或奖牌概率。
 
-* 有比赛目标时，先调 `coach_target read`，再调 `coach_focus`。没有目标时不能用
+* 有比赛目标时，结合 `coach_target read` 和 `coach_focus` 的信息取舍；当前上下文已有
+  足够信息时不必重复查询，也不要求固定调用顺序。能力排名是参考，排在前三之外或尚未
+  映射到能力的节点可以训练，说明理由即可。没有目标时不能用
   rating、游标或地图后继猜长期方向；先建立比赛、日期、结果目标、团队模式、时间预算
   和能力优先级。
 * `coach_focus` 给的是比赛能力重点，不是知识点清单。每次训练必须说明它服务哪个能力、
@@ -92,9 +94,10 @@
 
 下面九条是硬规则，每条都能机械检查。违反就是没做好本职工作：
 
-1. **给训练指令前，必须先调 `coach_target`/`coach_focus`，再调 `coach_next`**。
-   不许只凭 rating 或地图后继挑知识点 ——
-   它可能在地图里根本不存在，或者前置还没满足。
+1. **给训练指令前，核对目标、当前重点和地图前置**。
+   用 `coach_target`、`coach_focus`、`coach_next` 按需补足信息；上下文已有足够依据时
+   不重复读取，不规定调用顺序。不许只凭 rating 或地图后继挑知识点，
+   节点必须真实存在，前置必须满足。
 2. **每条指令必须带地图节点 id**。节点 id 只能从地图取到，
    所以这条会自动逼你先读地图。
 3. **一次只给一个动作。** 禁止候选列表、禁止「你可以考虑…」、
@@ -186,16 +189,18 @@
 
 ### 复习别把新知识挤没
 
-这套系统的价值在**往前推**，不在原地保温。一个月的表里排满复习，
-等于这个月没往前走。
+训练要改善目标比赛中的表现。新知识、复习和迁移都可能带来改善，
+安排哪一个要看目标、已有表现和投入收益。
 
 **但他自己会想先复习** —— 复习舒服（做过的东西有把握）、
 开新知识点难受（进入状态有成本）。所以这个平衡**得你把**，
 不能等他主动说"我想学新的"：
 
 * 排课时，复习块**按火候排**（放得最久的那几个才排），不是按"他提了哪个"排；
-* 比火候更靠前的是**推进**：只要他状态还行、时间够，块里就该有一个是开新知识点的；
-* 反过来说，**火候高到离谱的（放了一两个月）也不能不管** —— 那种是该重讲，不是该复习。
+* **推进不等于开新知识点**：按目标与实际表现选择新课、复习、迁移或 VP，
+  不为填课表硬开新点，也不让熟悉题反复练习代替真实改善；
+* **放了一两个月的知识点先核对保持情况**，再决定检测、复习或重讲，
+  不把间隔长直接当作已经忘光。
   * **提法按规则 3：一次一个动作** ——「这块我建议验一下，90 分钟三题，做不做？」
     并且**说清你为什么觉得该验了**（拿上面的记录当证据）。
     他说做，你才走下面三步。
@@ -339,9 +344,16 @@
   他说会了就别再给。
 * **注释密度跟他的样例走** —— 样例里注释少就少，别逐行注释。
 
-**讲完才出题**：讲完用 `coach_assign` 布置，**带上 `teachMinutes`** ——
-没有那一段它会被拒绝（新知识点不给 `teachMinutes` 就是又回到"直接出题"了）。
-讲多久**你定**，别参考任何固定值：看你判断他需要多少。
+**新课动作要留出教学时间**：用 `coach_assign` 布置时带 `teachMinutes`，
+它是计划时长，不证明已经讲过，也不证明学生理解。实际开始学习后可用 `coach_mark`
+记为 studying；是否学会仍需学生表现和检测。讲多久由你根据需要判断。
+
+**续课只留必要笔记**：发生值得接着讲的进展或中断时，用 `coach_note write` 保存
+当前判断、尚未确认之处和下一次接续点，不记录整段聊天、不每次回复都写。
+`coach_status` 和新会话状态会带上最近笔记，需要细节再用 `coach_note read`。
+引用学生回应可填 `studentQuote`；工具只核对当前会话里真实学生原话，身份和位置自动记录，
+不要让学生提供消息 ID。核对成功只证明原话存在，不证明理解正确。没有原话依据的笔记
+仍可保存，但必须当作教练判断；笔记不改游标、进度、待办或检测结果，不替代掌握证据。
 
 ⚠️ **例外：游标自己那个节点不算"新知识点"** —— 接着做，不逼你再讲一遍。
 **但例外有条件：这个节点得真讲过**（有教学痕迹）。游标可以被挪到一个
@@ -457,7 +469,8 @@
 
 ## 训练数据操作纪律（P0）
 
-* 修改训练数据（地图、进度、日程）前，必须：① 告知将改什么 ② 等确认后执行。
+* 已授权课程内的事实记录、续课笔记和做题用时正常保存，不重复要求确认。
+  替换或删除个人数据、大幅改变目标或课程时，先说明将改什么，等确认后执行。
 * 禁止擅自修改他人的训练数据。
 * 挑题之前先查 AC 记录，不重复喂已经会的题。
 
@@ -506,8 +519,8 @@
   （一个写、一个验、一个造 hack 数据）。
   末尾并行死磕多道难题是 ICPC 最常见的败因 —— 风险是最后一道都做不出。
 * 每场记一句：**题目是不是全都被读过**（读漏题比做不出更亏）。
-* **赛前 2 周不塞新技巧**：只确认已经练到"不用想"的东西 ——
-  压力下只有自动化了的技能不掉线。
+* **临近比赛通常优先巩固与模拟**：按剩余时间、掌握基础和预期收益取舍；
+  必要的新内容可安排，说明收益、风险和验收方式，不按固定两周一律禁止。
 
 ## 紧急停止（最高优先级）
 

package/dev/coaching-contract-check.mjs

@@ -9,7 +9,7 @@ function shape(schema, value) {
     assert.ok(value && typeof value === 'object' && !Array.isArray(value))
     if (schema.additionalProperties === false) for (const key of Object.keys(value)) assert.ok(key in schema.properties, `unexpected field ${key}`)
     for (const [key, field] of Object.entries(schema.properties ?? {})) {
-      if (field.required) assert.ok(key in value, `missing field ${key}`)
+      if (field.required === true || (Array.isArray(schema.required) && schema.required.includes(key))) assert.ok(key in value, `missing field ${key}`)
       if (key in value) shape(field, value[key])
     }
   } else if (schema.type === 'array') {
@@ -38,6 +38,7 @@ test('registered coaching tools expose cited findings, sourced teaching and comp
     assert.ok(tools.get('coach_postmortem').parameters.properties.findings)
     assert.ok(tools.get('coach_focus').output.schema.properties.profile.properties?.id, 'SDK needs explicit nested profile fields')
     assert.ok(tools.get('coach_vp_import').parameters.properties.events.items.properties.measurements)
+    assert.equal((await call('coach_grade', { results: [] })).ok, false, 'an absent paper has a complete refusal shape')
     assert.ok((await call('coach_target', { action: 'profiles' })).availableProfiles.length)
     const missing = await call('coach_postmortem', { eventId: 'unknown', findings: [] })
     assert.equal(missing.ok, false)
@@ -91,3 +92,128 @@ test('registered coaching tools expose cited findings, sourced teaching and comp
     rmSync(dir, { recursive: true, force: true })
   }
 })
+
+test('a planned lecture is not reported as past teaching', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'coach-lecture-plan-'))
+  const previous = { data: process.env.COACH_DATA_DIR, db: process.env.COACH_DB }
+  try {
+    writeFileSync(join(dir, 'MAP.yaml'), 'meta: {version: 1}\nnodes:\n  - {id: A, name: 基础, depends: []}\n  - {id: B, name: 新课, depends: [A]}\n')
+    writeFileSync(join(dir, 'PROGRESS.yaml'), 'version: 1\ncursor: A\nnodes:\n  A: {status: learned}\n')
+    process.env.COACH_DATA_DIR = dir
+    process.env.COACH_DB = join(dir, 'unused.db')
+    const { apply } = await import('../index.js?lecture-plan-contract')
+    const tools = new Map()
+    apply({ tools: { register: tool => tools.set(tool.name, tool) }, inject() {}, on() {} })
+    const assigned = await tools.get('coach_assign').execute({ node: 'B', deliverable: '独立写出状态与转移', teachMinutes: 20, why: '先解释状态为何保留这些信息' })
+    assert.equal(assigned.accepted, true, assigned.reject)
+    assert.equal((await tools.get('coach_set_cursor').execute({ node: 'B' })).ok, true)
+    const status = await tools.get('coach_status').execute({})
+    assert.equal(status.cursorTaught, '', 'planning teaching must not create a teaching date')
+    assert.equal(status.pendingActions.find(item => item.node === 'B').teachMinutes, 20)
+  } finally {
+    for (const [key, value] of [['COACH_DATA_DIR', previous.data], ['COACH_DB', previous.db]]) {
+      if (value === undefined) delete process.env[key]
+      else process.env[key] = value
+    }
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+test('teaching notes survive reload, reach the native hook and never certify mastery', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'coach-note-contract-'))
+  const previous = { data: process.env.COACH_DATA_DIR, db: process.env.COACH_DB }
+  try {
+    writeFileSync(join(dir, 'MAP.yaml'), 'meta: {version: 1}\nnodes:\n  - {id: A, name: 基础, depends: []}\n')
+    writeFileSync(join(dir, 'PROGRESS.yaml'), 'version: 1\ncursor: A\nnodes: {}\n')
+    process.env.COACH_DATA_DIR = dir
+    process.env.COACH_DB = join(dir, 'unused.db')
+    const quote = '这里的状态只需要保留容量，不需要保留选取顺序。'
+    const query = { readSession: async (id) => {
+      assert.equal(id, 'session-1')
+      return { session: { id }, inheritedEventCount: 0, events: [{ type: 'user/message', seq: 7, data: {
+        id: 'message-7', role: 'user', source: { kind: 'user' }, content: [{ type: 'text', text: quote }],
+      } }] }
+    } }
+    const register = async (suffix) => {
+      const tools = new Map(), hooks = new Map()
+      const { apply } = await import(`../index.js?note-contract-${suffix}`)
+      apply({ tools: { register: tool => tools.set(tool.name, tool) }, inject() {},
+        get: service => service === 'sessionQuery' ? query : undefined,
+        on: (event, handler) => hooks.set(event, handler) })
+      return { tools, hooks }
+    }
+    const first = await register('first')
+    const note = first.tools.get('coach_note')
+    assert.ok(note, 'one native tool must expose teaching continuation')
+    const exec = { agent: { session: { id: 'session-1' } } }
+    const plain = await note.execute({ action: 'write', summary: '准备续讲状态含义；尚未核对学生回应', nextStep: '先查看已有的课堂上下文' })
+    shape(note.output.schema, plain)
+    assert.equal(plain.ok, true, plain.reject)
+    assert.ok(!('studentEvidence' in plain.notes[0]), 'unquoted notes do not invent student evidence')
+    const saved = await note.execute({ action: 'write', summary: '学生能解释容量维，但迁移能力尚未核对', nextStep: '用另一个背包变式确认状态含义', studentQuote: quote }, exec)
+    shape(note.output.schema, saved)
+    assert.equal(saved.ok, true, saved.reject)
+    assert.equal(saved.notes.at(-1).studentEvidence.messageId, 'message-7')
+    const bad = await note.execute({ action: 'write', summary: '不存在的回应', nextStep: '继续核对', studentQuote: '这句话不在学生的消息中' }, exec)
+    shape(note.output.schema, bad)
+    assert.equal(bad.ok, false)
+    const second = await register('reload')
+    const read = await second.tools.get('coach_note').execute({ action: 'read' })
+    shape(second.tools.get('coach_note').output.schema, read)
+    assert.deepEqual(read.notes, saved.notes)
+    assert.equal(read.total, 2)
+    const status = await second.tools.get('coach_status').execute({})
+    shape(second.tools.get('coach_status').output.schema, status)
+    assert.equal(status.verifiedCount, 0)
+    assert.equal(status.learnedCount, 0)
+    assert.equal(status.cursorTaught, '', 'even a real student quote cannot become a teaching/contact certificate')
+    assert.match(status.teachingContext, /背包变式/)
+    const hook = second.hooks.get('agent/pre-step')
+    const decision = { kind: 'enter', messages: [] }
+    const injected = await hook({ step: 1, messages: [] }, async () => decision)
+    const message = injected.messages.at(-1)
+    assert.equal(message.source.kind, 'plugin:acmer-coach', 'format v4 requires producer-owned source kind')
+    assert.ok(message.content.some(block => block.type === 'text' && block.text.includes('背包变式')))
+    assert.deepEqual(await hook({ step: 2, messages: [] }, async () => decision), decision)
+  } finally {
+    for (const [key, value] of [['COACH_DATA_DIR', previous.data], ['COACH_DB', previous.db]]) {
+      if (value === undefined) delete process.env[key]
+      else process.env[key] = value
+    }
+    rmSync(dir, { recursive: true, force: true })
+  }
+})
+
+test('continuation follows a noted unfinished lesson while the cursor stays on its prerequisite', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'coach-note-pending-'))
+  const previous = { data: process.env.COACH_DATA_DIR, db: process.env.COACH_DB }
+  try {
+    writeFileSync(join(dir, 'MAP.yaml'), 'meta: {version: 1}\nnodes:\n  - {id: A, name: 基础, depends: []}\n  - {id: B, name: 新课, depends: [A]}\n')
+    writeFileSync(join(dir, 'PROGRESS.yaml'), 'version: 1\ncursor: A\nnodes:\n  A: {status: learned}\n')
+    process.env.COACH_DATA_DIR = dir
+    process.env.COACH_DB = join(dir, 'unused.db')
+    const tools = new Map(), hooks = new Map()
+    const { apply } = await import('../index.js?note-pending-contract')
+    apply({ tools: { register: tool => tools.set(tool.name, tool) }, inject() {}, on: (event, handler) => hooks.set(event, handler) })
+    const assigned = await tools.get('coach_assign').execute({ node: 'B', deliverable: '解释状态含义', teachMinutes: 20, why: '沿着已学前置开始新课' })
+    assert.equal(assigned.accepted, true, assigned.reject)
+    assert.equal((await tools.get('coach_note').execute({ action: 'write', node: 'B', summary: '状态含义已解释，尚未检查学生回应', nextStep: '继续核对容量维度' })).ok, true)
+    const status = await tools.get('coach_status').execute({})
+    assert.equal(status.cursor, 'A', 'showing continuity must not move the cursor')
+    assert.match(status.teachingContext, /容量维度/)
+    const latest = await tools.get('coach_note').execute({ action: 'read' })
+    assert.equal(latest.node, 'B')
+    assert.equal(latest.total, 1)
+    const explicit = await tools.get('coach_note').execute({ action: 'read', node: 'A' })
+    assert.equal(explicit.node, 'A', 'explicit node selection overrides the context fallback')
+    assert.equal(explicit.total, 0)
+    const injected = await hooks.get('agent/pre-step')({ step: 1, messages: [] }, async () => ({ kind: 'enter', messages: [] }))
+    assert.ok(injected.messages.at(-1).content.some(block => block.type === 'text' && block.text.includes('容量维度')))
+  } finally {
+    for (const [key, value] of [['COACH_DATA_DIR', previous.data], ['COACH_DB', previous.db]]) {
+      if (value === undefined) delete process.env[key]
+      else process.env[key] = value
+    }
+    rmSync(dir, { recursive: true, force: true })
+  }
+})

package/dev/curriculum-check.mjs

@@ -53,7 +53,7 @@ function validateShape(schema, value) {
     assert.equal(typeof value, 'object'); assert.notEqual(value, null)
     if (schema.additionalProperties === false) for (const key of Object.keys(value)) assert.ok(key in schema.properties, `unexpected ${key}`)
     for (const [key, child] of Object.entries(schema.properties)) {
-      if (child.required) assert.ok(key in value, `missing ${key}`)
+      if (child.required === true || (Array.isArray(schema.required) && schema.required.includes(key))) assert.ok(key in value, `missing ${key}`)
       if (key in value) validateShape(child, value[key])
     }
   } else if (schema.type === 'array') {

package/dev/parity-check.mjs

@@ -73,7 +73,7 @@ const onlyA = namesA.filter((n) => !namesB.includes(n))
 check('开源版没有丢掉任何原有工具', onlyB.length === 0, onlyB.join(',') || '（没丢）')
 // 新增的只能是「搭环境 / 拉数据 / 查知识 / 长期课程」这几类 —— 它们补的正是
 // 开源版缺的那些基础设施（原版靠本地已有的库和 skill，别人没有）。
-const EXPECTED_NEW = new Set(['coach_setup', 'coach_wiki', 'coach_import', 'coach_curriculum', 'coach_target', 'coach_focus', 'coach_scope', 'coach_postmortem', 'coach_vp_import', 'coach_vp_connect', 'coach_vp_sync', 'coach_vp_contests', 'coach_vp_replay'])
+const EXPECTED_NEW = new Set(['coach_setup', 'coach_wiki', 'coach_import', 'coach_curriculum', 'coach_note', 'coach_target', 'coach_focus', 'coach_scope', 'coach_postmortem', 'coach_vp_import', 'coach_vp_connect', 'coach_vp_sync', 'coach_vp_contests', 'coach_vp_replay'])
 check('新增的都在预期内（搭建 / 检索 / 课程 / 比赛 / VP）',
   onlyA.every((n) => EXPECTED_NEW.has(n)), onlyA.join(',') || '（无新增）')
 // 对照副本可能也已经升级到 20/21 个工具；检查原工具集合，不能拿固定数量拒绝新版。
@@ -130,10 +130,14 @@ for (const [tool, args, label] of CALLS) {
   try { rb = norm(await tb.execute(args, undefined)) } catch (e) { eb = e.message }
   // Legacy hosts have no goal layer; only its explicit no-target defaults may be absent.
   if (tool === 'coach_assign' && rb && !('targetAligned' in rb) &&
-      (ra?.targetAligned === true || (ra?.accepted === false && rb.accepted === false && ra.reject === rb.reject && ra.targetAligned === false)) &&
+      ra?.targetAligned === false &&
       Array.isArray(ra.competencies) && !ra.competencies.length) {
     delete ra.targetAligned; delete ra.competencies
   }
+  // A legacy host cannot return the new empty continuation field.
+  if (tool === 'coach_status' && rb && !('teachingContext' in rb) && ra?.teachingContext === '') {
+    delete ra.teachingContext
+  }
   const sa = JSON.stringify(ra ?? { ERR: ea }), sb = JSON.stringify(rb ?? { ERR: eb })
   if (sa === sb) { check(`${tool} · ${label}`, true) }
   else {
@@ -154,8 +158,16 @@ for (const [tool, args, label] of CALLS.filter((c) => c[0] !== 'coach_diagnose')
   try { va = await ta.execute(args, undefined) } catch { continue }
   try { vb = await tb.execute(args, undefined) } catch { continue }
   const ra = strip(ta.output.render(args, va)[0]?.text ?? '')
-  const rb = strip(tb.output.render(args, vb)[0]?.text ?? '')
-  const same = ra === rb
+  const legacyText = tb.output.render(args, vb)[0]?.text ?? ''
+  // The old lecture label overstated its evidence; only this intentional label changes.
+  const rb = strip(tool === 'coach_status'
+    ? legacyText.replace(/　讲于 (\d{4}-\d{2}-\d{2})/g, '　接触记录 $1（不证明理解）')
+    : legacyText)
+  // Only the changed goal-led advice is excluded; schedule facts still match byte for byte.
+  const scheduleAdvice = (text) => text
+    .replace(/^⚠️ \*\*复习别把新知识挤没了。\*\*.*剩下的时间留给推进。$/m, '<COACH_ADVICE>')
+    .replace(/^根据目标、剩余时间和实际表现，选择新课、复习、迁移或 VP。上面的间隔只供判断；不要为了填满课表持续开新知识点。$/m, '<COACH_ADVICE>')
+  const same = tool === 'coach_schedule' ? scheduleAdvice(ra) === scheduleAdvice(rb) : ra === rb
   check(`渲染 · ${tool} · ${label}`, same, same ? '' : '文本不一致')
 }
 

package/dev/run-all.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 # 一条命令跑全套验收。
 #
-# 八套：
+# 验收项：
 #   verify / verify-shape   主验收和全工具形状扫描
 #   w1-check                解绑、夹具闸门、规则注入
 #   wiki-check              OI Wiki 检索
@@ -9,6 +9,7 @@
 #   curriculum-check        长期课程、版本、阶段验收与任务关联
 #   curriculum-evidence     编排证据目录、引用与事件身份
 #   strategy-check          比赛目标、VP 证据、复盘与重点选择
+#   teaching                续课笔记、学生原话与进度保留
 #   parity-check            和线上那份的保真度对比
 #
 # 主验收跑的是**已安装副本**（不是源码）—— 那才是运行时真正加载的东西。
@@ -46,7 +47,7 @@ run() {  # run <名字> <命令...>
     echo "✓ $(echo "$out" | tail -1)"
   else
     echo "✗"
-    echo "$out" | tail -25 | sed 's/^/    /'
+    echo "$out" | sed 's/^/    /'
     RC=1
   fi
 }
@@ -67,6 +68,7 @@ run "evidence"      node --test dev/curriculum-evidence-check.mjs
 run "strategy"      node --test dev/strategy-check.mjs
 run "catalog"       node --test dev/catalog-check.mjs
 run "coach-contract" node --test dev/coaching-contract-check.mjs
+run "teaching"      node --test dev/teaching-check.mjs
 run "VP-client"     node dev/vp-client-check.mjs
 run "VP-sync"       node --test dev/vp-sync-check.mjs
 run "migration"     node --test dev/workspace-migration-check.mjs

package/dev/strategy-check.mjs

@@ -209,19 +209,50 @@ test('first-use focus has a complete refusal shape and targets reject unknown ca
   } finally { rmSync(dir, { recursive: true, force: true }) }
 })
 
-test('target route rejects an unrelated progress node but allows a course-bound route', () => {
+test('target route allows a fourth-ranked target capability without imposing the focus ranking', () => {
   const { dir, store } = fixture()
   try {
+    assert.equal(store.target('set', {
+      expectedRevision: 0, contest: '西安区域赛', date: '2026-10-18', result: '区域赛金牌',
+      weeklyHours: 35, priorities: [
+        { id: 'contest-reading', weight: 100 },
+        { id: 'contest-decision', weight: 90 },
+        { id: 'dp-modeling', weight: 80 },
+        { id: 'graph-modeling', weight: 10 },
+      ],
+    }).ok, true)
+    assert.deepEqual(store.focus().postponed, ['graph-modeling'])
+    const route = store.route('最短路', { purpose: 'progress', courseBound: false })
+    assert.equal(route.ok, true)
+    assert.equal(route.targetAligned, true)
+    assert.deepEqual(route.competencyIds, ['graph-modeling'])
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
+test('target route reports alignment without rejecting the coach choice', () => {
+  const { dir, store } = fixture()
+  try {
+    assert.equal(store.route('树状数组').targetAligned, false, 'no target is not an alignment claim')
     store.target('set', {
       expectedRevision: 0, contest: '西安区域赛', date: '2026-10-18', result: '区域赛金牌',
       weeklyHours: 35, priorities: [{ id: 'dp-modeling', weight: 100 }],
     })
-    const unrelated = store.route('树状数组', { purpose: 'progress', courseBound: false })
-    assert.equal(unrelated.ok, false)
-    assert.match(unrelated.reject, /dp-modeling|当前重点/)
-    const courseBound = store.route('树状数组', { purpose: 'progress', courseBound: true })
-    assert.equal(courseBound.ok, true)
-    assert.equal(courseBound.courseBound, true)
+    for (const options of [
+      { purpose: 'progress', courseBound: false },
+      { purpose: 'progress', courseBound: true },
+      { purpose: 'remediation', courseBound: false },
+      { purpose: 'review', courseBound: false },
+    ]) {
+      const unrelated = store.route('树状数组', options)
+      assert.equal(unrelated.ok, true)
+      assert.equal(unrelated.reject, '')
+      assert.equal(unrelated.targetAligned, false)
+      assert.deepEqual(unrelated.competencyIds, [])
+      assert.equal(unrelated.courseBound, options.courseBound)
+    }
+    const alignedReview = store.route('动态规划基础', { purpose: 'review', courseBound: true })
+    assert.equal(alignedReview.targetAligned, true)
+    assert.deepEqual(alignedReview.competencyIds, ['dp-modeling'])
   } finally { rmSync(dir, { recursive: true, force: true }) }
 })
 
@@ -313,5 +344,8 @@ test('corrupt stored strategy data returns a structured refusal', () => {
     const result = store.target('read')
     assert.equal(result.ok, false)
     assert.match(result.reject, /TARGET.yaml/)
+    const route = store.route('最短路')
+    assert.equal(route.ok, false)
+    assert.match(route.reject, /TARGET.yaml/)
   } finally { rmSync(dir, { recursive: true, force: true }) }
 })