acmer-coach 2.4.0 → 2.6.0

package/dev/grading-check.mjs

@@ -0,0 +1,161 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, writeFileSync, readFileSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { parse, stringify } from 'yaml'
+import { collectEvidence } from '../lib/curriculum-evidence.js'
+import { evaluateExitChecks } from '../lib/curriculum-planning.js'
+
+async function fixture(run, nodeRecord = { status: 'studying' }) {
+  const dir = mkdtempSync(join(tmpdir(), 'coach-grading-'))
+  const previous = { data: process.env.COACH_DATA_DIR, db: process.env.COACH_DB }
+  try {
+    process.env.COACH_DATA_DIR = dir
+    process.env.COACH_DB = join(dir, 'unused.db')
+    writeFileSync(join(dir, 'MAP.yaml'), 'meta: {version: 1}\nnodes:\n  - {id: A, name: 基础, depends: []}\n')
+    const path = join(dir, 'PROGRESS.yaml')
+    writeFileSync(path, stringify({ version: 1, cursor: 'A', nodes: { A: nodeRecord }, pending: {
+      node: 'A', totalMinutes: 90, passScore: 4, maxScore: 6,
+      problems: [
+        { problemId: 'P1', band: '易', weight: 1, cfRating: 1200, source: 'pool' },
+        { problemId: 'P2', band: '中', weight: 2, cfRating: 1600, source: 'pool' },
+        { problemId: 'P3', band: '难', weight: 3, cfRating: 1900, source: 'pool' },
+      ],
+    } }))
+    const { apply } = await import(`../index.js?grading=${encodeURIComponent(dir)}`)
+    const tools = new Map()
+    apply({ tools: { register: tool => tools.set(tool.name, tool) }, inject() {}, on() {} })
+    await run({ grade: tools.get('coach_grade'), call: (name, args) => tools.get(name).execute(args),
+      ledger: () => parse(readFileSync(path, 'utf8')), bytes: () => readFileSync(path, 'utf8') })
+  } 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 })
+  }
+}
+
+const results = (extra = {}) => ['P1', 'P2', 'P3'].map(problemId => ({ problemId, solved: true, minutes: 15, ...extra }))
+const independentExit = ledger => evaluateExitChecks({ exitChecks: [{ node: 'A', minEvents: 1, independent: true }] },
+  collectEvidence(ledger), [], '2000-01-01')[0]
+
+test('a passing paper without independence facts cannot create a mastery certificate', async () => {
+  await fixture(async ({ grade, ledger }) => {
+    const result = await grade.execute({ results: results() })
+    assert.equal(result.ok, true)
+    assert.equal(result.outcome, 'passed')
+    assert.equal(result.status, 'studying')
+    assert.equal(result.verified, false)
+    assert.equal(result.independence, 'unknown')
+    assert.equal(result.verifiedAt, 0)
+    const record = ledger().nodes.A
+    assert.equal(record.checks[0].independent, undefined)
+    assert.equal(record.checks[0].verifiedAt, 0)
+    assert.equal(independentExit(ledger()).passed, false, 'unknown independence cannot satisfy the course exit condition')
+    assert.equal(ledger().pending, undefined)
+    assert.match(grade.output.render({}, result)[0].text, /独立性.*未|未.*独立/)
+  })
+})
+
+test('a passing paper with a helped solution stays a paper pass without a certificate', async () => {
+  await fixture(async ({ grade, ledger }) => {
+    const reported = results({ independent: true })
+    reported[1].independent = false
+    const result = await grade.execute({ results: reported })
+    assert.equal(result.outcome, 'passed')
+    assert.equal(result.independence, 'assisted')
+    assert.equal(result.verified, false)
+    assert.equal(result.status, 'studying')
+    assert.equal(result.verifiedAt, 0)
+    assert.equal(ledger().nodes.A.checks[0].independent, false)
+    assert.equal(independentExit(ledger()).passed, false)
+    assert.match(grade.output.render({}, result)[0].text, /有帮助/)
+  })
+})
+
+test('explicitly independent solved problems certify a passing paper and carry the evidence into course checks', async () => {
+  await fixture(async ({ grade, ledger }) => {
+    const result = await grade.execute({ results: results({ independent: true }) })
+    assert.equal(result.verified, true)
+    assert.equal(result.status, 'verified')
+    assert.equal(result.independence, 'independent')
+    assert.equal(result.verifiedAt, 1900)
+    assert.equal(ledger().nodes.A.checks[0].independent, true)
+    assert.equal(independentExit(ledger()).passed, true)
+    assert.equal(ledger().nodes.A.passes, undefined, 'exam records must not invent practice records')
+    assert.match(grade.output.render({}, result)[0].text, /不代表隔日.*迁移/)
+  })
+})
+
+test('weighted passing still requires explicit independence for every solved problem', async () => {
+  await fixture(async ({ grade }) => {
+    const reported = results({ independent: true })
+    delete reported[2].independent
+    const result = await grade.execute({ results: reported })
+    assert.equal(result.outcome, 'passed')
+    assert.equal(result.verified, false)
+    assert.equal(result.independence, 'unknown')
+  })
+  await fixture(async ({ grade }) => {
+    const reported = results({ independent: true })
+    reported[1] = { problemId: 'P2', solved: false, minutes: 15 }
+    const result = await grade.execute({ results: reported })
+    assert.equal(result.score, 4)
+    assert.equal(result.verified, true, 'the existing weighted pass line remains valid; unsolved problems do not prove mastery')
+  })
+})
+
+test('explicit independence never certifies a failing or overtime paper', async () => {
+  for (const [reported, outcome] of [
+    [results({ independent: true, solved: false }), 'failed'],
+    [results({ independent: true, minutes: 40 }), 'overTime'],
+  ]) await fixture(async ({ grade, ledger }) => {
+    const result = await grade.execute({ results: reported })
+    assert.equal(result.outcome, outcome)
+    assert.equal(result.verified, false)
+    assert.equal(result.status, 'studying')
+    assert.equal(result.verifiedAt, 0)
+    assert.equal(independentExit(ledger()).passed, false)
+  })
+})
+
+test('unknown or assisted passing records preserve historical verified and learned states', async () => {
+  const previousCheck = { date: '2026-09-01', outcome: 'passed', score: 6, maxScore: 6, passScore: 4,
+    minutes: 45, limit: 90, verifiedAt: 1600, selfReported: 0, problems: [] }
+  for (const status of ['verified', 'learned']) await fixture(async ({ grade, ledger }) => {
+    const result = await grade.execute({ results: results() })
+    assert.equal(result.status, status)
+    assert.equal(result.verified, false, 'status may be historical; verified describes this attempt only')
+    assert.equal(result.verifiedAt, 0)
+    assert.equal(ledger().nodes.A.at, '2026-09-01')
+    assert.deepEqual(ledger().nodes.A.checks[0], previousCheck)
+    assert.equal(ledger().nodes.A.checks.length, 2)
+  }, { status, at: '2026-09-01', checks: [previousCheck] })
+})
+
+test('malformed grading fields and contradictory IDs are rejected without changing the pending paper', async () => {
+  await fixture(async ({ grade, bytes }) => {
+    const before = bytes()
+    for (const invalid of [
+      { independent: 'true' }, { independent: null }, { solved: 'true' },
+      { minutes: -1 }, { minutes: Infinity }, { minutes: Number.MAX_VALUE }, { minutes: '15' }, { problemId: '' }, { problemId: 'P2' },
+    ]) {
+      const reported = results()
+      Object.assign(reported[0], invalid)
+      let rejected
+      try { rejected = await grade.execute({ results: reported }) }
+      catch (error) {
+        assert.equal(error.code, 'INVALID_ARGS', 'the native SDK may reject malformed types before tool execution')
+      }
+      if (rejected) {
+        assert.equal(rejected.ok, false, JSON.stringify(invalid))
+        assert.equal(rejected.verified, false)
+        assert.equal(rejected.independence, 'unknown')
+        for (const key of grade.output.schema.required) assert.ok(key in rejected, `missing refusal field ${key}`)
+      }
+      assert.equal(bytes(), before)
+    }
+  })
+})

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,18 @@ 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_schedule' && Array.isArray(ra?.blockKinds) && Array.isArray(rb?.blockKinds) && rb.blockKinds.length === 3) {
+    const added = ra.blockKinds.slice(3)
+    if (JSON.stringify(added) === JSON.stringify([{ kind: 'diagnostic', minutes: 15, name: '短诊断' }, { kind: 'vp', minutes: 300, name: '完整 VP' }])) ra.blockKinds = ra.blockKinds.slice(0, 3)
+  }
+  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 +162,17 @@ 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('／diagnostic 15min（短诊断）／vp 300min（完整 VP）', '')
+    .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,9 @@ 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 "grading"       node --test dev/grading-check.mjs
+run "training"      node --test dev/training-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 }) }
 })

package/dev/teaching-check.mjs

@@ -0,0 +1,191 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, readFileSync, rmdirSync, unlinkSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { createTeachingNotes } from '../lib/teaching.js'
+
+const AT = '2026-10-11T10:00:00.000Z'
+const EXEC = { agent: { session: { id: 'session-1' } } }
+const QUOTE = '状态不需要保存选择顺序，只需要保存剩余容量。'
+const userEvent = (overrides = {}) => ({
+  type: 'user/message', seq: 7,
+  data: { id: 'message-7', role: 'user', source: { kind: 'user' }, content: [{ type: 'text', text: QUOTE }] },
+  ...overrides,
+})
+
+function fixture(t) {
+  const root = mkdtempSync(join(tmpdir(), 'acmer-coach-teaching-'))
+  const path = join(root, 'PROGRESS.json')
+  const initial = {
+    version: 1, cursor: 'dp', updated: '2026-10-10',
+    nodes: { dp: { status: 'verified', taught: '2026-10-09', passes: [{ date: '2026-10-10' }] } },
+    pending: { node: 'graph', date: '2026-10-11', problems: ['fixture-problem'] },
+    pendingActions: { dp: { node: 'dp', deliverable: '写出状态含义' } },
+    verified_problems: { 'fixture-problem': { source: 'fixture' } },
+  }
+  writeFileSync(path, JSON.stringify(initial))
+  t.after(() => { unlinkSync(path); rmdirSync(root) })
+  const loadProgress = () => JSON.parse(readFileSync(path, 'utf8'))
+  const saveProgress = (p) => { writeFileSync(path, JSON.stringify(p)); return p }
+  const dependencies = {
+    loadProgress, saveProgress,
+    loadMap: () => ({ byId: new Map([['dp', { id: 'dp', name: '动态规划基础' }], ['graph', { id: 'graph', name: '最短路' }]]) }),
+    getSessionQuery: () => undefined,
+    now: () => AT,
+  }
+  return { initial, loadProgress, saveProgress, dependencies, create: () => createTeachingNotes(dependencies) }
+}
+
+test('续课笔记留在既有节点账本，重建后可读且不改变掌握与待测卷', async (t) => {
+  const f = fixture(t)
+  const result = await f.create().write({ summary: '状态含义还需检查', nextStep: '用三个物品的小例子让学生解释状态' })
+  assert.equal(result.ok, true)
+  assert.equal(result.node, 'dp')
+  assert.deepEqual(result.notes, [{ at: AT, summary: '状态含义还需检查', nextStep: '用三个物品的小例子让学生解释状态' }])
+  assert.deepEqual(f.create().read(), result)
+  const expected = structuredClone(f.initial)
+  expected.nodes.dp.lessonNotes = [{ ...result.notes[0], studentEvidence: null }]
+  assert.deepEqual(f.loadProgress(), expected)
+})
+
+test('无效知识点、空白和超长笔记不能写入账本', async (t) => {
+  const f = fixture(t)
+  const notes = f.create()
+  const valid = { summary: '仍需辨析状态', nextStep: '解释一个反例' }
+  for (const change of [
+    { node: 'unknown' }, { node: 123 }, { summary: '   ' }, { summary: 'x'.repeat(1001) },
+    { nextStep: '' }, { nextStep: 'x'.repeat(501) }, { studentQuote: ' ' },
+    { studentQuote: 'x'.repeat(1501) },
+  ]) {
+    const result = await notes.write({ ...valid, ...change })
+    assert.equal(result.ok, false, JSON.stringify(change))
+    assert.deepEqual(result.notes, [])
+    assert.equal(result.total, 0)
+    assert.deepEqual(f.loadProgress(), f.initial)
+  }
+  for (const limit of [0, -1, 21, 1.5, '5']) assert.equal(notes.read({ limit }).ok, false)
+})
+
+test('学生原话通过当前原生会话核对并保存稳定出处', async (t) => {
+  const f = fixture(t)
+  let queried
+  f.dependencies.getSessionQuery = () => ({ readSession: async (id) => {
+    queried = id
+    return { session: { id }, events: [userEvent()] }
+  } })
+  const result = await f.create().write({ summary: '能区分容量和顺序，尚未检查代码', nextStep: '独立实现转移', studentQuote: QUOTE }, EXEC)
+  assert.equal(queried, 'session-1')
+  assert.equal(result.ok, true)
+  assert.deepEqual(result.notes[0].studentEvidence, { sessionId: 'session-1', seq: 7, messageId: 'message-7', quote: QUOTE })
+  assert.equal(f.loadProgress().nodes.dp.status, 'verified')
+})
+
+test('伪造原话、插件消息、跨会话内容或缺失出处不能成为学生依据', async (t) => {
+  const invalidEvent = [
+    userEvent({ data: { ...userEvent().data, content: [{ type: 'text', text: '别的答复' }] } }),
+    userEvent({ data: { ...userEvent().data, source: { kind: 'plugin:coach' } } }),
+    userEvent({ data: { ...userEvent().data, role: 'assistant' } }),
+    userEvent({ seq: -1 }), userEvent({ seq: undefined }),
+    userEvent({ data: { ...userEvent().data, id: '' } }),
+    userEvent({ type: 'compaction/message' }),
+    userEvent({ data: { ...userEvent().data, content: [{ type: 'image', text: QUOTE }] } }),
+  ]
+  for (const event of invalidEvent) {
+    const f = fixture(t)
+    f.dependencies.getSessionQuery = () => ({ readSession: async () => ({ session: { id: 'session-1' }, events: [event] }) })
+    const result = await f.create().write({ summary: '判断', nextStep: '继续', studentQuote: QUOTE }, EXEC)
+    assert.equal(result.ok, false)
+    assert.deepEqual(f.loadProgress(), f.initial)
+  }
+  const f = fixture(t)
+  const params = { summary: '判断', nextStep: '继续', studentQuote: QUOTE }
+  assert.equal((await f.create().write(params, EXEC)).ok, false, '无会话查询服务必须拒绝')
+  f.dependencies.getSessionQuery = () => ({ readSession: async () => ({ session: { id: 'another-session' }, events: [userEvent()] }) })
+  assert.equal((await f.create().write(params, EXEC)).ok, false)
+  assert.equal((await f.create().write(params)).ok, false, '无当前调用会话必须拒绝')
+  f.dependencies.getSessionQuery = () => ({ readSession: async () => { throw new Error('unavailable') } })
+  assert.equal((await f.create().write(params, EXEC)).ok, false)
+  assert.deepEqual(f.loadProgress(), f.initial)
+})
+
+test('没有游标时找最近一次续课，默认只读最近五条并保留全部历史', async (t) => {
+  const f = fixture(t)
+  const notes = f.create()
+  for (let i = 1; i <= 6; i++) await notes.write({ summary: `第${i}次讲解`, nextStep: '继续解释转移' })
+  assert.equal(notes.read().total, 6)
+  assert.equal(notes.read().notes.length, 5)
+  assert.equal(notes.read().notes[0].summary, '第2次讲解')
+  f.dependencies.now = () => '2026-10-11T11:00:00.000Z'
+  await f.create().write({ node: 'graph', summary: '图上松弛还要澄清', nextStep: '比较两条路径' })
+  const progress = f.loadProgress()
+  progress.cursor = ''
+  progress.pendingActions = {}
+  f.saveProgress(progress)
+  assert.equal(f.create().read().node, 'graph')
+  assert.equal(f.create().read({ node: 'dp', limit: 20 }).notes.length, 6)
+})
+
+test('续课上下文短且标明教练判断，核对原话不等于证明掌握', async (t) => {
+  const f = fixture(t)
+  const notes = f.create()
+  assert.equal(notes.context(f.loadProgress()), '')
+  await notes.write({ summary: '状态含义还需辨析'.repeat(100), nextStep: '用小例子解释状态'.repeat(60) })
+  const context = notes.context(f.loadProgress())
+  assert.ok(context.length <= 700)
+  assert.match(context, /教练判断/)
+  assert.match(context, /下次接续/)
+  assert.equal(notes.context(f.loadProgress(), 'graph'), '')
+  f.dependencies.getSessionQuery = () => ({ readSession: async () => ({ session: { id: 'session-1' }, events: [userEvent()] }) })
+  await f.create().write({ summary: '对状态有一个合理解释', nextStep: '独立写出转移', studentQuote: QUOTE }, EXEC)
+  const grounded = f.create().context(f.loadProgress())
+  assert.match(grounded, /原话已核对/)
+  assert.match(grounded, /不代表掌握/)
+  assert.match(grounded, /独立写出转移/)
+})
+
+test('原话查询期间其他工具保存的进度不会被旧快照覆盖', async (t) => {
+  const f = fixture(t)
+  let release
+  f.dependencies.getSessionQuery = () => ({ readSession: () => new Promise((resolve) => { release = resolve }) })
+  const writing = f.create().write({ summary: '状态解释待验证', nextStep: '写出转移', studentQuote: QUOTE }, EXEC)
+  const updated = f.loadProgress()
+  updated.cursor = 'graph'
+  updated.nodes.graph = { status: 'studying', checks: [{ outcome: 'needs-work' }] }
+  updated.pendingActions.dp.deliverable = '更新后的动作'
+  f.saveProgress(updated)
+  release({ session: { id: 'session-1' }, events: [userEvent()] })
+  assert.equal((await writing).ok, true)
+  const saved = f.loadProgress()
+  assert.equal(saved.cursor, 'graph')
+  assert.deepEqual(saved.nodes.graph, updated.nodes.graph)
+  assert.deepEqual(saved.pendingActions, updated.pendingActions)
+  assert.deepEqual(saved.pending, updated.pending)
+  assert.deepEqual(saved.verified_problems, updated.verified_problems)
+  assert.equal(saved.nodes.dp.lessonNotes.length, 1)
+})
+
+test('续课优先最近未完动作的笔记，显式读取和默认写入不受选择影响', async (t) => {
+  const f = fixture(t)
+  await f.create().write({ summary: '游标节点的旧笔记', nextStep: '继续状态解释' })
+  const progress = f.loadProgress()
+  progress.pendingActions.graph = { node: 'graph', deliverable: '解释松弛' }
+  f.saveProgress(progress)
+  f.dependencies.now = () => '2026-10-11T11:00:00.000Z'
+  await f.create().write({ node: 'graph', summary: '刚讲到路径比较', nextStep: '继续比较两条路径' })
+  const notes = f.create()
+  assert.equal(notes.read().node, 'graph')
+  assert.match(notes.context(f.loadProgress()), /刚讲到路径比较/)
+  assert.equal(notes.read({ node: 'dp' }).node, 'dp')
+  assert.match(notes.context(f.loadProgress(), 'dp'), /游标节点的旧笔记/)
+  f.dependencies.now = () => '2026-10-11T12:00:00.000Z'
+  assert.equal((await f.create().write({ summary: '仍写入当前游标', nextStep: '继续游标节点' })).node, 'dp')
+  assert.equal(f.loadProgress().cursor, 'dp')
+  assert.deepEqual(f.loadProgress().pendingActions, progress.pendingActions)
+  assert.equal(f.create().read().node, 'dp', '多个未完动作按笔记时间选最近')
+  const finished = f.loadProgress()
+  delete finished.pendingActions.graph
+  delete finished.pendingActions.dp
+  f.saveProgress(finished)
+  assert.equal(f.create().read().node, 'dp', '没有未完动作回到当前游标')
+})