acmer-coach 2.3.1 → 2.4.0

package/dev/coaching-contract-check.mjs

@@ -0,0 +1,93 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, writeFileSync, rmSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+function shape(schema, value) {
+  if (schema.type === 'object') {
+    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 (key in value) shape(field, value[key])
+    }
+  } else if (schema.type === 'array') {
+    assert.ok(Array.isArray(value))
+    if (schema.items) value.forEach(item => shape(schema.items, item))
+  } else if (schema.type === 'integer') assert.ok(Number.isInteger(value))
+  else assert.equal(typeof value, schema.type)
+}
+
+test('registered coaching tools expose cited findings, sourced teaching and complete refusal shapes', async () => {
+  const dir = mkdtempSync(join(tmpdir(), 'coach-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')
+    process.env.COACH_DATA_DIR = dir
+    process.env.COACH_DB = join(dir, 'unused.db')
+    const { apply } = await import('../index.js?coaching-contract')
+    const tools = new Map()
+    apply({ tools: { register: tool => tools.set(tool.name, tool) }, inject() {}, on() {} })
+    const call = async (name, args) => {
+      const tool = tools.get(name)
+      const result = await tool.execute(args)
+      shape(tool.output.schema, result)
+      return result
+    }
+    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.ok((await call('coach_target', { action: 'profiles' })).availableProfiles.length)
+    const missing = await call('coach_postmortem', { eventId: 'unknown', findings: [] })
+    assert.equal(missing.ok, false)
+    const target = await call('coach_target', { action: 'set', expectedRevision: 0, contest: '样本训练', date: '2026-10-17', result: '稳定发挥', weeklyHours: 25,
+      priorities: [{ id: 'graph-modeling', weight: 10 }] })
+    assert.equal(target.ok, true, target.reject)
+    await call('coach_vp_import', { events: [{ eventId: 'vp-contract', contest: 'VP', date: '2026-10-10', problems: [{ problemId: 'A', status: 'WA' }] }] })
+    const facts = await call('coach_curriculum', { action: 'assess' })
+    const fact = facts.evidence.find(entry => entry.source === 'vp')
+    assert.ok(fact)
+    const saved = await call('coach_postmortem', { eventId: 'vp-contract', findings: [{ competency: 'graph-modeling', status: 'confirmed',
+      cause: '对照题面和代码确认建图方向写反了', evidenceRefs: [fact.id] }] })
+    assert.equal(saved.ok, true, saved.reject)
+    const focus = await call('coach_focus', {})
+    assert.equal(focus.focus[0].gapCount, 1)
+    assert.match(focus.text, /已确认|确认短板/)
+    const measurementImport = await call('coach_vp_import', { events: [{ eventId: 'measured-contract', contest: 'VP', date: '2026-10-10',
+      problems: [{ problemId: 'A', status: 'AC' }], measurements: [{ competency: 'contest-reading', metric: 'missed-reading', value: 0, passed: true, independent: true }] }] })
+    assert.equal(measurementImport.ok, true, measurementImport.reject)
+    const measured = await call('coach_curriculum', { action: 'assess', evidenceEventIds: ['measured-contract'] })
+    assert.equal(measured.evidence.find(entry => entry.metric === 'missed-reading')?.value, 0)
+    const gap = (await call('coach_curriculum', { action: 'assess', evidenceEventIds: ['vp-contract'] })).evidence.find(entry => entry.signal === 'gap')
+    const created = await call('coach_curriculum', { action: 'create', expectedRevision: 0, goal: '区域赛稳定建图', reason: '针对已经确认的建图错误，用两场零错误指标验收', phases: [{
+      id: 'graph-measured', title: '稳定建图', kind: 'training', finding: 'gap', nodes: [], competencies: ['graph-modeling'],
+      outcome: '两场不同的VP都能独立正确建模', exitCriteria: '两场独立验收无建模错误',
+      basis: '对照题面和代码已确认建图方向错误', goalContribution: '减少区域赛建模题错误提交', priorityReason: '现有事实显示建模方向错误需要先修', estimatedHours: 5,
+      evidenceRefs: [gap.id], uncertainty: '', diagnosticMethod: '', exitChecks: [{ competency: 'graph-modeling', minEvents: 2, independent: true, metric: 'model-errors', maxValue: 0 }],
+    }] })
+    assert.equal(created.ok, true, created.reject)
+    const now = new Date()
+    const date = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`
+    for (let i = 0; i < 2; i++) {
+      assert.equal((await call('coach_vp_import', { events: [{ eventId: `metric-exit-${i}`, contest: 'VP', date, problems: [{ problemId: 'B', status: 'AC' }],
+        measurements: [{ competency: 'graph-modeling', metric: 'model-errors', value: 0, passed: true, independent: true, occurredAt: new Date().toISOString() }] }] })).ok, true)
+      const state = await call('coach_curriculum', { action: 'read' })
+      assert.equal(state.exitCheckResults[0].matchedEvents, i + 1)
+      if (i === 0) assert.equal((await call('coach_curriculum', { action: 'advance', expectedRevision: state.revision, reason: '只有一场，不能通过两场的验收条件' })).ok, false)
+    }
+    const finished = await call('coach_curriculum', { action: 'advance', expectedRevision: created.revision, reason: '两场不同的新VP都有独立且已验收的零建模错误测量' })
+    assert.equal(finished.status, 'complete', finished.reject)
+    const scope = await call('coach_scope', { id: '最短路' })
+    assert.equal(scope.id, '最短路')
+    assert.ok(scope.sources.length)
+    assert.ok(scope.recognition.length)
+    await call('coach_scope', { id: '不存在的卡片' })
+  } 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

@@ -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,13 +39,14 @@ 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') {
@@ -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_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,12 @@ 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 === true || (ra?.accepted === false && rb.accepted === false && ra.reject === rb.reject && ra.targetAligned === false)) &&
+      Array.isArray(ra.competencies) && !ra.competencies.length) {
+    delete ra.targetAligned; delete ra.competencies
+  }
   const sa = JSON.stringify(ra ?? { ERR: ea }), sb = JSON.stringify(rb ?? { ERR: eb })
   if (sa === sb) { check(`${tool} · ${label}`, true) }
   else {
@@ -136,7 +142,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]])) })) }
   }
 }
 

package/dev/run-all.sh

@@ -65,6 +65,11 @@ 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 "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 }],
@@ -116,8 +250,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 }) }
 })

package/dev/vp-client-check.mjs

@@ -7,6 +7,7 @@ import { createVpClient } from '../lib/vp-client.js'
 const root = mkdtempSync(join(tmpdir(), 'acmer-coach-vp-'))
 let account = { id: 1, handle: 'A', display_name: 'Coach A' }
 let mismatch = false
+let nextPage = false
 const fetchImpl = async (url, options = {}) => {
   const path = new URL(url).pathname
   const body = options.body ? JSON.parse(options.body) : {}
@@ -19,8 +20,8 @@ const fetchImpl = async (url, options = {}) => {
   if (path.endsWith('/api/coach/contests')) return json({ account, contests: [{ id: 7, title: 'VP 7', status: 'ended' }] })
   if (path.endsWith('/api/coach/sync')) return json({
     account: mismatch ? { id: 1, handle: 'A' } : account,
-    submissions: [{ id: 9, contest_id: 7, verdict: 'AC' }], events: [], contests: [],
-    next_cursor: { submission_id: 9, event_id: 0 }, has_more: false,
+    submissions: [{ id: nextPage ? 10 : 9, contest_id: 7, verdict: nextPage ? 'WA' : 'AC' }], events: [], contests: [],
+    next_cursor: { submission_id: nextPage ? 10 : 9, event_id: 0 }, has_more: !nextPage,
   })
   if (path.endsWith('/api/coach/replay/7')) return json({ account, visualization: { team_events: [] } })
   throw new Error(`unexpected ${url}`)
@@ -34,7 +35,16 @@ try {
   await client.finish({ code: 'A' })
   const synced = await client.sync()
   assert.equal(synced.account.id, 1)
+  assert.equal(synced.hasMore, true, 'first page must expose continuation')
+  assert.deepEqual(synced.pageCounts, { submissions: 1, events: 0, contests: 0 })
   assert.equal(JSON.parse(readFileSync(join(root, 'vp-accounts', '1', 'SYNC.json'))).account.id, 1)
+  nextPage = true
+  const secondPage = await client.sync()
+  assert.equal(secondPage.hasMore, false, 'last page must expose completion')
+  assert.deepEqual(secondPage.pageCounts, { submissions: 1, events: 0, contests: 0 }, 'page counts must not include old cached rows')
+  assert.deepEqual(secondPage.submissions.map(item => item.id), [9, 10], 'incremental pages must retain earlier accepted runs')
+  assert.deepEqual(JSON.parse(readFileSync(join(root, 'vp-accounts', '1', 'SYNC.json'))).submissions.map(item => item.id), [9, 10])
+  nextPage = false
   await client.finish({ code: 'B' })
   assert.equal((await client.status()).account.id, 2)
   assert.equal((await client.contests()).contests[0].id, 7)