acmer-coach 2.3.1 → 2.5.0

package/dev/curriculum-check.mjs

@@ -24,6 +24,7 @@ const phases = [
   { id: 'foundation', title: '稳定基础能力', outcome: '独立建模与实现', nodes: ['B', 'C'], exitCriteria: '独立变式与延迟复测', requiredVerified: ['B', 'C'] },
   { id: 'transfer', title: '组合迁移', outcome: '识别组合题机制', nodes: ['D'], exitCriteria: '无标签混合题独立完成', requiredVerified: ['D'] },
 ].map((phase) => ({ ...phase, kind: 'training', finding: 'gap',
+  exitChecks: phase.nodes.map((node) => ({ node, minEvents: 1 })),
   basis: '已存在对应知识点的未通过检测记录，需要针对性训练',
   goalContribution: '通过独立建模和稳定实现提升区域赛可完成题数',
   priorityReason: '先修复已观测的基础问题，再进入有依赖的组合训练',
@@ -38,20 +39,21 @@ function prove(progress, node) {
 function fixture() {
   const dataDir = mkdtempSync(join(testBase, 'coach-curriculum-'))
   const progress = { nodes: structuredClone(seedNodes), pendingActions: {} }
+  const clock = { at: '2026-10-09T12:00:00+08:00' }
   const options = { dataDir, loadMap: () => ({ byId }), loadProgress: () => progress,
-    now: () => new Date('2026-10-09T12:00:00+08:00') }
+    now: () => new Date(clock.at) }
   const store = createCurriculumStore(options)
   const create = (extra = {}) => store.execute({ action: 'create', expectedRevision: 0,
     goal: '区域赛稳定表现，长期向 WF 发展', baseline: '水平与队伍缺口已核实，尚需独立检测',
     weeklyHours: 30, phases, reason: '根据用户目标与真实训练表现建立课程路线', ...extra })
-  return { dataDir, progress, options, store, create }
+  return { dataDir, progress, options, clock, store, create }
 }
 function validateShape(schema, value) {
   if (schema.type === 'object') {
     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') {
@@ -61,21 +63,203 @@ function validateShape(schema, value) {
 }
 
 const phaseFor = (nodes, extra = {}) => ({ ...phases[0], nodes, requiredVerified: [...nodes],
+  exitChecks: nodes.map((node) => ({ node, minEvents: 1 })),
   evidenceRefs: seedEvidence.filter((entry) => nodes.includes(entry.node)).map((entry) => entry.id), ...extra })
 const diagnostic = (nodes = ['B']) => phaseFor(nodes, {
   id: 'diagnostic', title: '核实当前能力缺口', kind: 'diagnostic', finding: 'unknown',
   basis: '尚无足够的实际结果证明具体短板，先进行诊断',
   uncertainty: '尚未确认是否独立建模、实现稳定性或熟练度存在缺口',
   diagnosticMethod: '独立完成小规模变式，记录结果并对失败代码进行判因',
-  evidenceRefs: [], requiredVerified: [], estimatedHours: 2,
+  evidenceRefs: [], requiredVerified: [], exitChecks: [], estimatedHours: 2,
 })
 const provisional = (nodes = ['D']) => phaseFor(nodes, {
   id: 'future', kind: 'provisional', finding: 'unknown', basis: '该方向目前仅是与目标相关的远期假设，尚待诊断',
   uncertainty: '尚未取得这些节点的训练结果，进入前须重新核实依据',
-  evidenceRefs: [], requiredVerified: [], estimatedHours: 0,
+  evidenceRefs: [], requiredVerified: [], exitChecks: [], estimatedHours: 0,
 })
 const advance = (f, revision = f.store.snapshot().revision) => f.store.execute({ action: 'advance', expectedRevision: revision, reason: '依据本阶段实际产生的检测与训练记录评估成果' })
 
+test('new training stages reject narrative-only exit criteria', () => {
+  const f = fixture()
+  const phase = phaseFor(['B'])
+  delete phase.exitChecks
+  const result = f.create({ phases: [phase] })
+  assert.equal(result.ok, false)
+  assert.match(result.reject, /exitChecks/)
+  assert.equal(f.store.load(), null)
+})
+
+test('structured exits count distinct fresh events and delayed independent performance', () => {
+  const f = fixture()
+  const phase = phaseFor(['B'], { exitChecks: [{ node: 'B', minEvents: 2, minDistinctDays: 2, independent: true, maxMinutes: 45 }] })
+  assert.equal(f.create({ phases: [phase] }).ok, true)
+  f.progress.nodes.B.status = 'verified'
+  f.progress.nodes.B.passes = [{ date: '2026-10-09', problemId: 'P1', solved: true, independent: true, minutes: 30 }]
+  let state = f.store.execute({ action: 'read' })
+  assert.equal(advance(f).ok, false)
+  assert.equal(state.exitCheckResults[0].matchedEvents, 1)
+  f.progress.nodes.B.passes.push({ date: '2026-10-09', problemId: 'P2', solved: true, independent: true, minutes: 30 })
+  state = f.store.execute({ action: 'read' })
+  assert.equal(state.exitCheckResults[0].matchedEvents, 2)
+  assert.equal(state.exitCheckResults[0].distinctDays, 1)
+  assert.equal(advance(f).ok, false)
+  f.clock.at = '2026-10-10T12:00:00+08:00'
+  f.progress.nodes.B.passes.push({ date: '2026-10-10', problemId: 'P3', solved: true, independent: true, minutes: 60 })
+  assert.equal(advance(f).ok, false)
+  f.progress.nodes.B.passes.push({ date: '2026-10-10', problemId: 'P4', solved: true, independent: true, minutes: 35 })
+  assert.equal(advance(f).status, 'complete')
+})
+
+test('structured exits reject missing facts, repeated events and edits to old successes', () => {
+  const f = fixture()
+  f.progress.nodes.B.passes = [{ date: '2026-10-09', problemId: 'P-old', solved: true, independent: true, minutes: 90 }]
+  const phase = phaseFor(['B'], { exitChecks: [{ node: 'B', minEvents: 2, independent: true, maxMinutes: 45 }] })
+  assert.equal(f.create({ phases: [phase] }).ok, true)
+  f.progress.nodes.B.status = 'verified'
+  f.progress.nodes.B.passes[0].minutes = 30
+  prove(f.progress, 'B') // A passed check without an explicit independence fact cannot satisfy this rule.
+  assert.equal(f.store.execute({ action: 'read' }).exitCheckResults[0].matchedEvents, 0)
+  const fresh = { date: '2026-10-09', problemId: 'P-new', solved: true, independent: true, minutes: 25 }
+  f.progress.nodes.B.passes.push(fresh, structuredClone(fresh))
+  assert.equal(f.store.execute({ action: 'read' }).exitCheckResults[0].matchedEvents, 1)
+  assert.equal(advance(f).ok, false)
+  f.progress.nodes.B.passes.push({ ...fresh, problemId: 'P-another' })
+  assert.equal(advance(f).status, 'complete')
+})
+
+test('changing exit requirements resets the entry snapshot rather than reusing current success', () => {
+  const f = fixture(); assert.equal(f.create({ phases: [phaseFor(['B'])] }).ok, true)
+  prove(f.progress, 'B')
+  assert.deepEqual(f.store.execute({ action: 'read' }).missingFreshEvidence, [])
+  const phase = phaseFor(['B'], { exitChecks: [{ node: 'B', minEvents: 2 }] })
+  const result = f.store.execute({ action: 'revise', expectedRevision: 1, phases: [phase], reason: '原单次检测不足以证明稳定性，追加两次新检测条件' })
+  assert.equal(result.ok, true, result.reject)
+  assert.equal(result.exitCheckResults[0].matchedEvents, 0)
+  prove(f.progress, 'B'); assert.equal(advance(f).ok, false)
+  prove(f.progress, 'B'); assert.equal(advance(f).status, 'complete')
+})
+
+test('v2 courses remain unchanged on read and completed v2 phases survive explicit v3 repair', () => {
+  const f = fixture(); assert.equal(f.create().ok, true)
+  prove(f.progress, 'B'); prove(f.progress, 'C')
+  const old = parse(readFileSync(f.store.path, 'utf8'))
+  old.version = 2; old.current = 1; old.focusNodes = []
+  old.phases.forEach((phase) => { delete phase.exitChecks })
+  const bytes = stringify(old); writeFileSync(f.store.path, bytes)
+  const result = f.store.execute({ action: 'read' })
+  assert.equal(result.ok, true); assert.equal(result.needsReview, true)
+  assert.equal(readFileSync(f.store.path, 'utf8'), bytes)
+  assert.equal(f.store.assignment({ node: 'D', revision: 1 }).ok, false)
+  assert.equal(advance(f).ok, false)
+  const completed = f.store.load().phases[0]
+  const repaired = f.store.execute({ action: 'revise', expectedRevision: 1, phases: [completed, phases[1]], reason: '只为未完成阶段补可检查条件，保留已完成阶段原始依据' })
+  assert.equal(repaired.ok, true, repaired.reject)
+  assert.equal(repaired.exitCheckResults[0].matchedEvents, 0)
+  const saved = parse(readFileSync(f.store.path, 'utf8'))
+  assert.equal(saved.version, 3)
+  assert.deepEqual(saved.phases[0], completed)
+  assert.equal(saved.history.at(-1).previous.version, 2)
+})
+
+test('VP metric exits require baseline facts with the exact metric and finite value', () => {
+  const f = fixture()
+  const facts = [{ id: 'vp:old', eventId: 'old', source: 'vp', node: '', competency: 'contest-reading', date: '2026-10-08', signal: 'gap', summary: '已确认的漏读', fingerprint: 'old' }]
+  const store = createCurriculumStore({ ...f.options, loadStrategyEvidence: () => facts })
+  const phase = { ...phaseFor([]), id: 'vp-reading', competencies: ['contest-reading'], evidenceRefs: ['vp:old'],
+    exitChecks: [{ competency: 'contest-reading', minEvents: 2, metric: 'missed-reading', maxValue: 0 }] }
+  assert.equal(store.execute({ action: 'create', expectedRevision: 0, goal: '区域赛稳定读题', phases: [phase], reason: '依据已确认的漏读缺口，设两场零漏读的事实验收' }).ok, true)
+  const fresh = { ...facts[0], eventId: 'new', id: 'vp:new', date: '2026-10-09', signal: 'baseline' }
+  facts.push(fresh, { ...fresh, eventId: 'observation', id: 'vp:observation', signal: 'observation', metric: 'missed-reading', value: 0 })
+  assert.equal(store.execute({ action: 'read' }).exitCheckResults[0].matchedEvents, 0)
+  facts.push({ ...fresh, id: 'vp:new-measured', metric: 'missed-reading', value: 0 }, { ...fresh, id: 'vp:duplicate', metric: 'missed-reading', value: 0 })
+  assert.equal(store.execute({ action: 'read' }).exitCheckResults[0].matchedEvents, 1)
+  assert.equal(store.execute({ action: 'advance', expectedRevision: 1, reason: '只有一场合格的新事实，验证不会误判两场条件' }).ok, false)
+  facts.push({ ...fresh, id: 'vp:another', eventId: 'another', metric: 'missed-reading', value: 0 })
+  assert.equal(store.execute({ action: 'advance', expectedRevision: 1, reason: '两场不同的新事件都有零漏读的明确指标事实' }).status, 'complete')
+})
+
+test('malformed or uncovered structured exit rules are rejected before any write', () => {
+  for (const exitChecks of [[], [{ node: 'B', minEvents: 0 }], [{ node: 'C', minEvents: 1 }],
+    [{ node: 'B', competency: 'contest-reading', minEvents: 1 }], [{ node: 'B', minEvents: 1, minDistinctDays: 2 }],
+    [{ node: 'B', minEvents: 1, independent: 'true' }], [{ node: 'B', minEvents: 1, maxMinutes: 0 }],
+    [{ node: 'B', minEvents: 1, metric: 'missed-reading' }], [{ node: 'B', minEvents: 1, maxValue: 0 }],
+    [{ node: 'B', minEvents: 1 }, { node: 'B', minEvents: 2 }]]) {
+    const f = fixture(); const result = f.create({ phases: [phaseFor(['B'], { exitChecks })] })
+    assert.equal(result.ok, false, JSON.stringify(exitChecks))
+    assert.equal(f.store.load(), null)
+  }
+})
+
+test('future-dated events cannot meet training or diagnostic exit gates', () => {
+  for (const phase of [phaseFor(['B']), diagnostic()]) {
+    const f = fixture(); assert.equal(f.create({ phases: [phase] }).ok, true)
+    f.progress.nodes.B.status = 'verified'
+    f.progress.nodes.B.checks.push({ date: '2026-10-10', outcome: 'passed' })
+    assert.deepEqual(f.store.execute({ action: 'read' }).missingFreshEvidence, ['B'])
+    assert.equal(advance(f).ok, false)
+    f.clock.at = '2026-10-10T12:00:00+08:00'
+    assert.deepEqual(f.store.execute({ action: 'read' }).missingFreshEvidence, [])
+  }
+})
+
+test('exact occurrence times reject same-day earlier imports and future or malformed timestamps', () => {
+  const f = fixture(); assert.equal(f.create({ phases: [phaseFor(['B'])] }).ok, true)
+  f.progress.nodes.B.status = 'verified'
+  f.progress.nodes.B.passes = [
+    { date: '2026-10-09', problemId: 'P-earlier', solved: true, independent: true, minutes: 20, occurredAt: '2026-10-09T10:00:00+08:00' },
+    { date: '2026-10-09', problemId: 'P-future', solved: true, independent: true, minutes: 20, occurredAt: '2026-10-09T14:00:00+08:00' },
+    { date: '2026-10-09', problemId: 'P-invalid', solved: true, independent: true, minutes: 20, occurredAt: 'today' },
+  ]
+  assert.equal(f.store.execute({ action: 'read' }).exitCheckResults[0].matchedEvents, 0)
+  f.clock.at = '2026-10-09T15:00:00+08:00'
+  assert.equal(f.store.execute({ action: 'read' }).exitCheckResults[0].matchedEvents, 1)
+  assert.equal(advance(f).status, 'complete')
+})
+
+test('date-only performance exposes its timing precision instead of claiming exact chronology', () => {
+  const f = fixture(); assert.equal(f.create({ phases: [phaseFor(['B'])] }).ok, true)
+  prove(f.progress, 'B')
+  const result = f.store.execute({ action: 'read' })
+  assert.equal(result.exitCheckResults[0].matchedEvents, 1)
+  assert.ok(result.evidencePrecisionWarnings.some((warning) => warning.includes('同日')))
+  validateShape(curriculumTool(f.store).output.schema, result)
+})
+
+test('assess can retrieve the oldest unlabeled VP facts beyond the 200-item response window', () => {
+  const f = fixture(); f.progress.nodes = {}
+  const facts = Array.from({ length: 201 }, (_, index) => ({ id: `vp:fact-${index}`, eventId: `vp:contest-${index}`, source: 'vp',
+    node: '', competency: '', date: '2026-10-09', signal: 'observation', summary: `第${index}场自动同步事实`, fingerprint: `fact-${index}` }))
+  const store = createCurriculumStore({ ...f.options, loadStrategyEvidence: () => facts })
+  const all = store.execute({ action: 'assess' })
+  assert.equal(all.evidenceCount, 201); assert.equal(all.evidenceTruncated, true)
+  assert.ok(all.evidence.every((entry) => entry.eventId !== 'vp:contest-0'))
+  const tool = curriculumTool(store)
+  const selected = tool.execute({ action: 'assess', evidenceEventIds: ['vp:contest-0'] })
+  assert.equal(selected.ok, true, selected.reject)
+  assert.equal(selected.evidenceCount, 1); assert.equal(selected.evidenceTruncated, false)
+  assert.deepEqual(selected.evidence.map((entry) => entry.id), ['vp:fact-0'])
+  assert.ok(tool.parameters.evidenceEventIds)
+  validateShape(tool.output.schema, selected)
+  assert.equal(store.execute({ action: 'assess', evidenceEventIds: ['vp:contest-0'], evidenceNodes: ['B'] }).evidenceCount, 0)
+  assert.equal(store.execute({ action: 'assess', evidenceEventIds: ['vp:does-not-exist'] }).evidenceCount, 0)
+  assert.equal(store.execute({ action: 'assess' }).evidenceCount, 201)
+})
+
+test('assess rejects malformed event filters without changing the curriculum or exit evidence', () => {
+  const f = fixture(); assert.equal(f.create({ phases: [phaseFor(['B'])] }).ok, true)
+  const before = readFileSync(f.store.path, 'utf8')
+  for (const evidenceEventIds of ['vp:first', null, [1], [''], ['   ']]) {
+    const result = f.store.execute({ action: 'assess', evidenceEventIds })
+    assert.equal(result.ok, false, JSON.stringify(evidenceEventIds))
+    assert.match(result.reject, /evidenceEventIds/)
+  }
+  prove(f.progress, 'B')
+  assert.equal(f.store.execute({ action: 'assess', evidenceEventIds: ['vp:unrelated'] }).evidenceCount, 0)
+  assert.deepEqual(f.store.execute({ action: 'read' }).missingFreshEvidence, [])
+  assert.equal(readFileSync(f.store.path, 'utf8'), before)
+  assert.equal(advance(f).status, 'complete')
+})
+
 test('assess exposes only existing record refs; rating and statuses cannot justify a training stage', () => {
   const f = fixture(); f.progress.nodes = { A: { status: 'learned' }, B: { status: 'studying', rating: 1600 } }
   const assessed = f.store.execute({ action: 'assess' })
@@ -220,7 +404,7 @@ test('v1 route remains readable without writes; migration preserves completed st
   const result = f.store.execute({ action: 'revise', expectedRevision: 1, phases: [completed, phases[1]], reason: '为旧路线补齐未完成阶段的真实依据，保留已经完成的阶段' })
   assert.equal(result.ok, true, result.reject); assert.equal(result.revision, 2)
   const migrated = parse(readFileSync(f.store.path, 'utf8'))
-  assert.equal(migrated.version, 2); assert.equal(migrated.phases[0].kind, 'legacy')
+  assert.equal(migrated.version, 3); assert.equal(migrated.phases[0].kind, 'legacy')
   assert.equal(migrated.history[1].previous.version, 1)
 })
 
@@ -347,6 +531,7 @@ test('competency-only phases can use fresh VP evidence as their exit gate', () =
     basis: 'VP 已记录读题缺口，需要在真实比赛节奏中修复', goalContribution: '提高区域赛前半小时的可做题识别和取舍质量',
     priorityReason: '它直接决定队伍是否把时间用在能拿分的题上', estimatedHours: 6, uncertainty: '', diagnosticMethod: '',
     evidenceRefs: ['vp:old:contest-reading'],
+    exitChecks: [{ competency: 'contest-reading', minEvents: 1 }],
   }
   assert.equal(store.execute({ action: 'create', expectedRevision: 0, goal: '区域赛稳定表现', baseline: '已有一场 VP 的读题缺口记录', weeklyHours: 30, phases: [phase], reason: '根据 VP 的读题记录建立能力课程' }).ok, true)
   assert.deepEqual(store.snapshot().phaseCompetencies, ['contest-reading'])
@@ -389,6 +574,9 @@ test('plugin integration: cross-branch course assignments, detours, logging and
   const course = tools.get('coach_curriculum'); const assign = tools.get('coach_assign')
   const created = await course.execute({ action: 'create', expectedRevision: 0, goal: '测试长期路线', phases, reason: '依据训练表现建立可延续的阶段课程' })
   assert.equal(created.ok, true, created.reject)
+  const selectedEvidence = await course.execute({ action: 'assess', evidenceEventIds: ['check:B:0'] })
+  assert.equal(selectedEvidence.evidenceCount, 1)
+  assert.deepEqual(selectedEvidence.evidence.map((entry) => entry.eventId), ['check:B:0'])
   const candidates = await tools.get('coach_next').execute({ cursor: 'B' })
   const nextText = tools.get('coach_next').output.render({}, candidates)[0].text
   assert.match(nextText, /测试长期路线/)

package/dev/curriculum-evidence-check.mjs

@@ -37,8 +37,7 @@ test('catalog only contains real record entries, with a stable typed public shap
   const rows = rowsFor({ checks: [check()], diagnoses: [diagnosis()], passes: [practice()] })
   assert.equal(rows.length, 3)
   for (const row of rows) {
-    assert.deepEqual(Object.keys(row).sort(), ['id', 'eventId', 'source', 'node', 'date', 'signal', 'summary', 'fingerprint'].sort())
-    for (const key of Object.keys(row)) assert.equal(typeof row[key], 'string', key)
+    for (const key of ['id', 'eventId', 'source', 'node', 'date', 'signal', 'summary', 'fingerprint']) assert.equal(typeof row[key], 'string', key)
     assert.ok(row.id && row.eventId && row.fingerprint && row.summary)
     assert.equal(row.node, '区间 DP'); assert.equal(row.date, date)
     assert.ok(['check', 'diagnosis', 'practice', 'schedule'].includes(row.source))
@@ -52,6 +51,14 @@ test('failed and over-time checks are gaps; passed checks only establish a basel
   assert.deepEqual(rows.map((row) => row.source), ['check', 'check', 'check'])
 })
 
+test('structured performance fields are explicit facts rather than narrative guesses', () => {
+  const rows = rowsFor({ checks: [check('passed')], passes: [practice({ solved: true, independent: true, minutes: 32 })] })
+  assert.equal(rows[0].minutes, 45)
+  assert.equal(rows[0].independent, undefined)
+  assert.equal(rows[1].minutes, 32)
+  assert.equal(rows[1].independent, true)
+})
+
 test('abandoned checks and narrative diagnoses without code evidence never become gaps', () => {
   assert.deepEqual(rowsFor({ checks: [check('abandoned', { reason: '今天临时没时间' })],
     diagnoses: [diagnosis({ evidence: [] }), diagnosis({ evidence: undefined }),

package/dev/parity-check.mjs

@@ -73,8 +73,8 @@ 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'])
-check('新增的都在预期内（搭建 / 检索 / 导入 / 长期课程）',
+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 个工具；检查原工具集合，不能拿固定数量拒绝新版。
 const ORIGINAL_TOOLS = ['coach_ping', 'coach_next', 'coach_assign', 'coach_status',
@@ -128,6 +128,16 @@ for (const [tool, args, label] of CALLS) {
   let ra, rb, ea, eb
   try { ra = norm(await ta.execute(args, undefined)) } catch (e) { ea = e.message }
   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 === 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 {
@@ -136,7 +146,7 @@ for (const [tool, args, label] of CALLS) {
     const dk = [...new Set([...ka, ...kb])].filter((k) => JSON.stringify(ra?.[k]) !== JSON.stringify(rb?.[k]))
     const benign = dk.every((k) => ALLOWED.some(([n]) => k === n))
     if (benign) { check(`${tool} · ${label}`, true, `仅包名/版本不同（${dk.join(',')}）`) }
-    else { diff++; check(`${tool} · ${label}`, false, `差异字段：${dk.join(', ')}`) }
+    else { diff++; check(`${tool} · ${label}`, false, `差异字段：${dk.join(', ')}`); console.log(JSON.stringify({ current: Object.fromEntries(dk.map(k => [k, ra?.[k]])), legacy: Object.fromEntries(dk.map(k => [k, rb?.[k]])) })) }
   }
 }
 
@@ -148,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
 }
@@ -65,6 +66,12 @@ run "setup-check"   node dev/setup-check.mjs
 run "curriculum"    node --test dev/curriculum-check.mjs
 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
 if [ "${COACH_LIVE_INDEX+x}" = x ] || node -e "
   const fs=require('fs'), os=require('os'), path=require('path');
   process.exit(fs.existsSync(path.join(os.homedir(), '.dsh', 'profiles', 'web', 'node_modules', 'dsh-coach', 'index.js')) ? 0 : 1);

package/dev/strategy-check.mjs

@@ -5,15 +5,149 @@ import { join } from 'node:path'
 import { tmpdir } from 'node:os'
 import { createStrategyStore } from '../lib/strategy.js'
 
-function fixture() {
+function fixture(options = {}) {
   const dir = mkdtempSync(join(tmpdir(), 'acmer-coach-strategy-'))
   const store = createStrategyStore({
     dataDir: dir,
     competenciesPath: join(process.cwd(), 'assets', 'knowledge', 'COMPETENCIES.yaml'),
+    ...options,
   })
   return { dir, store }
 }
 
+test('invalid target constraints and VP numbers are rejected before changing ledgers', () => {
+  const { dir, store } = fixture()
+  try {
+    const target = { expectedRevision: 0, contest: 'VP', date: '2026-10-17', result: '稳定', weeklyHours: 25, priorities: [{ id: 'graph-modeling', weight: 10 }] }
+    for (const constraints of [[], null, 'bad']) assert.equal(store.target('set', { ...target, constraints }).ok, false)
+    assert.equal(store.target().ok, true)
+    assert.equal(store.target().revision, 0)
+    const event = { eventId: 'bad-numbers', contest: 'VP', date: '2026-10-10', problems: [{ problemId: 'A', status: 'AC' }] }
+    for (const [key, value] of [['solveMinutes', 'Infinity'], ['readMinutes', -1], ['attempts', 1.5], ['independent', 'yes'], ['occurredAt', 'yesterday']]) {
+      assert.equal(store.vpImport([{ ...event, problems: [{ ...event.problems[0], [key]: value }] }]).ok, false, key)
+    }
+    assert.equal(store.vpImport([{ ...event, durationMinutes: 'Infinity' }]).ok, false)
+    assert.equal(store.loadVp().revision, 0)
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
+test('local training day includes morning VP evidence and computes the local deadline', () => {
+  const { dir, store } = fixture({ now: () => new Date(2026, 9, 11, 0, 30) })
+  try {
+    store.target('set', { expectedRevision: 0, contest: 'VP', date: '2026-10-17', result: '稳定', weeklyHours: 25, priorities: [{ id: 'graph-modeling', weight: 10 }] })
+    store.vpImport([{ eventId: 'today', contest: 'VP', date: '2026-10-11', problems: [{ problemId: 'A', status: 'AC', independent: true, competencies: ['graph-modeling'] }] }])
+    assert.equal(store.focus().focus[0].baselineCount, 1)
+    assert.equal(store.focus().daysRemaining, 6)
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
+test('event measurements are explicit finite facts and sync preserves coach annotations', () => {
+  const { dir, store } = fixture()
+  try {
+    const event = { eventId: 'measured', contest: 'VP', date: '2026-10-10', problems: [{ problemId: 'A', status: 'AC' }] }
+    const measurements = [{ competency: 'contest-reading', metric: 'missed-reading', value: 0, passed: true, independent: true }]
+    assert.equal(store.vpImport([{ ...event, measurements }]).ok, true)
+    const metric = store.evidence().evidence.find(fact => fact.metric === 'missed-reading')
+    assert.ok(metric)
+    assert.equal(metric.signal, 'baseline')
+    assert.equal(metric.value, 0)
+    const invalid = store.vpImport([{ ...event, measurements: [{ ...measurements[0], value: 'Infinity' }] }])
+    assert.equal(invalid.ok, false)
+    store.vpImport([{ ...event, measurements, problems: [{ ...event.problems[0], independent: true, competencies: ['graph-modeling'] }] }])
+    const before = store.evidence().evidence.map(fact => fact.id)
+    store.vpImport([event], { source: 'sync' })
+    assert.deepEqual(store.evidence().evidence.map(fact => fact.id), before)
+    store.vpImport([{ ...event, problems: [{ problemId: 'A', status: 'WA' }] }], { source: 'sync' })
+    assert.equal(store.evidence().evidence.find(fact => fact.competency === 'graph-modeling').signal, 'observation')
+    assert.deepEqual(store.loadVp().events[0].measurements, measurements)
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
+test('successful VP observations never become repair priority or reported problems', () => {
+  const { dir, store } = fixture({ now: () => new Date('2026-10-11T12:00:00Z') })
+  try {
+    store.target('set', { expectedRevision: 0, contest: '训练目标', date: '2026-10-17', result: '稳定发挥', weeklyHours: 25,
+      priorities: [{ id: 'dp-modeling', weight: 10 }, { id: 'graph-modeling', weight: 10 }] })
+    store.vpImport(Array.from({ length: 5 }, (_, i) => ({ eventId: `dp-success-${i}`, contest: 'VP', date: '2026-10-10',
+      problems: [{ problemId: 'A', status: 'AC', independent: true, competencies: ['dp-modeling'] }] })))
+    const dp = store.focus().focus.find(item => item.id === 'dp-modeling')
+    assert.equal(dp.gapCount, 0)
+    assert.equal(dp.baselineCount, 5)
+    assert.doesNotMatch(dp.whyNow, /5 次相关问题|优先修复/)
+    assert.equal(dp.score, 10)
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
+test('hypotheses stay observations and confirmation requires cited facts from the same VP', () => {
+  const { dir, store } = fixture({ now: () => new Date('2026-10-11T12:00:00Z') })
+  try {
+    store.vpImport([{ eventId: 'reason-1', contest: 'VP', date: '2026-10-10',
+      problems: [{ problemId: 'B', status: 'WA', competencies: ['graph-modeling'] }] }])
+    const fact = store.evidence().evidence[0]
+    assert.equal(fact.signal, 'observation')
+    const hypothesis = { competency: 'graph-modeling', status: 'hypothesis', cause: '可能把边建反了，需要查代码确认', evidenceRefs: [fact.id] }
+    assert.equal(store.postmortem({ eventId: 'reason-1', findings: [hypothesis] }).ok, true)
+    assert.equal(store.evidence().evidence.some(entry => entry.signal === 'gap'), false)
+    const forged = store.postmortem({ eventId: 'reason-1', findings: [{ ...hypothesis, status: 'confirmed', evidenceRefs: ['fabricated'] }] })
+    assert.equal(forged.ok, false)
+    assert.equal(store.postmortem({ eventId: 'reason-1', findings: [{ ...hypothesis, status: 'confirmed' }] }).ok, true)
+    const gap = store.evidence().evidence.find(entry => entry.signal === 'gap')
+    assert.ok(gap)
+    assert.match(gap.summary, /边建反/)
+    store.vpImport([{ eventId: 'reason-1', contest: 'VP', date: '2026-10-10',
+      problems: [{ problemId: 'B', status: 'AC', independent: true, competencies: ['graph-modeling'] }] }])
+    assert.equal(store.evidence().evidence.some(entry => entry.signal === 'gap'), false, 'changed facts invalidate old confirmation')
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
+test('synced unlabelled facts can be cited without fabricating an algorithm tag', () => {
+  const { dir, store } = fixture()
+  try {
+    store.vpImport([{ eventId: 'unlabelled', contest: 'VP', date: '2026-10-10', problems: [{ problemId: 'A', status: 'WA' }] }])
+    const fact = store.evidence().evidence[0]
+    assert.ok(fact)
+    assert.equal(fact.competency, '')
+    assert.equal(store.postmortem({ eventId: 'unlabelled', findings: [{ competency: 'implementation-stability', status: 'confirmed',
+      cause: '检查代码后确认多组数据没有清空数组', evidenceRefs: [fact.id] }] }).ok, true)
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
+test('confirmed gaps are counted once per recent event and old edits do not refresh them', () => {
+  const { dir, store } = fixture({ now: () => new Date('2026-10-11T12:00:00Z') })
+  try {
+    store.target('set', { expectedRevision: 0, contest: '目标', date: '2026-10-17', result: '稳定发挥', weeklyHours: 25,
+      priorities: [{ id: 'graph-modeling', weight: 10 }, { id: 'dp-modeling', weight: 10 }] })
+    for (const [id, day] of [['recent', '2026-10-10'], ['old', '2026-08-01']]) {
+      store.vpImport([{ eventId: id, contest: 'VP', date: day, problems: ['A', 'B'].map(problemId => ({ problemId, status: 'WA', competencies: ['graph-modeling'] })) }])
+      const refs = store.evidence().evidence.filter(entry => entry.eventId === id && entry.source === 'vp').map(entry => entry.id)
+      assert.equal(store.postmortem({ eventId: id, date: '2026-10-11', findings: [{ competency: 'graph-modeling', status: 'confirmed',
+        cause: '核对题面与代码确认有向关系建反', evidenceRefs: refs }] }).ok, true)
+    }
+    const graph = store.focus().focus[0]
+    assert.equal(graph.id, 'graph-modeling')
+    assert.equal(graph.gapCount, 1)
+    assert.equal(graph.score, 20)
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
+test('target profiles and exact node scopes retain sources without claiming an exam syllabus', () => {
+  const { dir, store } = fixture()
+  try {
+    writeFileSync(join(dir, 'NODE_SCOPES.yaml'), 'version: 1\nnodes:\n  - id: 最短路\n    title: 最短路识别\n    sources: [{title: 原始资料, url: "https://oi-wiki.org/graph/shortest-path/"}]\n    appliesTo: [路径代价]\n    notFor: [负权直接套Dijkstra]\n')
+    writeFileSync(join(dir, 'CONTEST_PROFILES.yaml'), 'version: 1\nprofiles:\n  - id: regional-sample\n    title: 区域赛样本\n    status: provisional\n    scope: 样本范围\n    sources: []\n    competencyIds: [graph-modeling]\n    selectionGuidance: [先诊断]\n    limitations: [不是西安预测]\n')
+    const scoped = createStrategyStore({ dataDir: dir, competenciesPath: join(process.cwd(), 'assets', 'knowledge', 'COMPETENCIES.yaml'),
+      nodeScopesPath: join(dir, 'NODE_SCOPES.yaml'), contestProfilesPath: join(dir, 'CONTEST_PROFILES.yaml') })
+    assert.equal(scoped.scope('最短路').id, '最短路')
+    assert.equal(scoped.scope('最短路').sources.length, 1)
+    const saved = scoped.target('set', { expectedRevision: 0, contest: '西安', date: '2026-10-17', result: '稳定发挥', weeklyHours: 25,
+      profileId: 'regional-sample', priorities: [{ id: 'graph-modeling', weight: 10 }] })
+    assert.equal(saved.ok, true)
+    assert.equal(saved.profileId, 'regional-sample')
+    assert.equal(scoped.target('profiles').availableProfiles[0].status, 'provisional')
+    assert.match(scoped.focus().profile.limitations[0], /不是西安预测/)
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
 test('target is explicit and revision protected', () => {
   const { dir, store } = fixture()
   try {
@@ -66,7 +200,7 @@ test('first-use focus has a complete refusal shape and targets reject unknown ca
   const { dir, store } = fixture()
   try {
     const empty = store.focus()
-    assert.deepEqual(Object.keys(empty).sort(), ['contest', 'deadline', 'evidenceEvents', 'focus', 'ok', 'postmortems', 'postponed', 'reject'])
+    assert.deepEqual(Object.keys(empty).sort(), ['contest', 'daysRemaining', 'deadline', 'evidenceEvents', 'focus', 'ok', 'postmortems', 'postponed', 'profile', 'reject'])
     const rejected = store.target('set', {
       expectedRevision: 0, contest: '西安区域赛', date: '2026-10-18', result: '区域赛金牌',
       weeklyHours: 35, priorities: [{ id: 'invented-card', weight: 100 }],
@@ -75,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 }) }
 })
 
@@ -116,8 +281,8 @@ test('strategy exposes stable competency evidence for curriculum gates', () => {
       problems: [{ problemId: 'C', status: 'WA', competencies: ['contest-decision'] }] }])
     const result = store.evidence()
     assert.equal(result.ok, true)
-    assert.equal(result.evidence[0].id, 'vp:vp-evidence:C:contest-decision')
-    assert.equal(result.evidence[0].signal, 'gap')
+    assert.match(result.evidence[0].id, /^vp:vp-evidence:C:contest-decision:[a-f0-9]{64}$/)
+    assert.equal(result.evidence[0].signal, 'observation')
     assert.equal(result.evidence[0].competency, 'contest-decision')
   } finally { rmSync(dir, { recursive: true, force: true }) }
 })
@@ -179,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 }) }
 })