acmer-coach 2.3.0 → 2.4.0

package/lib/curriculum.js

@@ -4,7 +4,7 @@ import { join } from 'node:path'
 import { randomUUID } from 'node:crypto'
 import { parse, stringify } from 'yaml'
 import { collectEvidence } from './curriculum-evidence.js'
-import { normalizePhases, validatePlan, knownNodes, prerequisitesOf, missingFreshEvidence } from './curriculum-planning.js'
+import { normalizePhases, validatePlan, knownNodes, prerequisitesOf, missingFreshEvidence, evaluateExitChecks } from './curriculum-planning.js'
 
 const clean = (value) => String(value ?? '').trim()
 const dateOf = (now) => {
@@ -51,7 +51,7 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
       throw err
     }
     const doc = parse(raw)
-    if (!doc || ![1, 2].includes(doc.version) || !Number.isInteger(doc.revision) || doc.revision < 1 ||
+    if (!doc || ![1, 2, 3].includes(doc.version) || !Number.isInteger(doc.revision) || doc.revision < 1 ||
       !['active', 'complete'].includes(doc.status) || typeof doc.goal !== 'string' || !clean(doc.goal) ||
       typeof doc.baseline !== 'string' || typeof doc.deadline !== 'string' ||
       typeof doc.focusUntil !== 'string' || typeof doc.updated !== 'string' ||
@@ -63,8 +63,8 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
         ['reason', 'at', 'fromPhase', 'toPhase'].some((key) => typeof entry[key] !== 'string'))) {
       throw new Error('CURRICULUM.yaml 损坏或版本不支持，请检查文件；不会当作没有计划覆盖它。')
     }
-    doc.phases = normalizePhases(doc.phases, loadMap().byId, { legacy: doc.version === 1, completed: doc.phases.slice(0, doc.current) })
-    if (doc.version === 2 && (typeof doc.enteredAt !== 'string' || !Number.isFinite(Date.parse(doc.enteredAt)) ||
+    doc.phases = normalizePhases(doc.phases, loadMap().byId, { legacy: doc.version === 1, allowMissingChecks: doc.version < 3, completed: doc.phases.slice(0, doc.current) })
+    if (doc.version >= 2 && (typeof doc.enteredAt !== 'string' || !Number.isFinite(Date.parse(doc.enteredAt)) ||
       !Array.isArray(doc.entryEvidenceRefs) || doc.entryEvidenceRefs.some((ref) => typeof ref !== 'string') ||
       !Array.isArray(doc.entryEvidenceEvents) || doc.entryEvidenceEvents.some((ref) => typeof ref !== 'string'))) {
       throw new Error('课程的阶段进入记录无效；不能猜测哪些记录是在本阶段产生的。')
@@ -97,7 +97,7 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
       focusNodes: [], phaseCompetencies: [], focusUntil: '', focusExpired: false, requiredVerified: [], missingVerified: [],
       pendingNodes: [], roadmap: [], history: [], updated: '',
       needsReview: false, planningWarnings: [], evidence: [], evidenceCount: 0, evidenceTruncated: false,
-      missingPrerequisites: [], missingFreshEvidence: [],
+      missingPrerequisites: [], missingFreshEvidence: [], exitChecks: [], exitCheckResults: [], evidencePrecisionWarnings: [],
       remainingEstimatedHours: 0, estimatedWeeks: 0, budgetWarnings: [],
     }
     if (!doc) return empty
@@ -105,13 +105,17 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
     const progress = loadProgress()
     const catalog = evidence()
     const planningWarnings = []
-    try { validatePlan(doc.phases, { byId: loadMap().byId, progress, catalog, current: doc.current }) }
+    try { if (doc.status === 'active') validatePlan(doc.phases, { byId: loadMap().byId, progress, catalog, current: doc.current }) }
     catch (err) { planningWarnings.push(err.message) }
     const missingPrerequisites = phase.prerequisites.filter((node) => !knownNodes(progress).has(node))
+    const exitCheckResults = doc.version >= 2 ? evaluateExitChecks(phase, catalog, doc.entryEvidenceRefs, dateOf(() => new Date(doc.enteredAt)), doc.entryEvidenceEvents, dateOf(now), doc.enteredAt, now().toISOString()) : []
     return {
       ...empty, exists: true, revision: doc.revision, status: doc.status, goal: doc.goal,
       baseline: doc.baseline, weeklyHours: doc.weeklyHours, deadline: doc.deadline,
       phaseId: phase.id, phaseTitle: phase.title, outcome: phase.outcome, exitCriteria: phase.exitCriteria,
+      exitChecks: phase.exitChecks, exitCheckResults,
+      evidencePrecisionWarnings: catalog.some((entry) => (phase.nodes.includes(entry.node) || phase.competencies.includes(entry.competency)) && entry.occurredAt === undefined)
+        ? ['部分证据只有日期：进入快照排除了既有旧事件，但同日后导入的事件不能核验发生在阶段进入之前还是之后。'] : [],
       focusNodes: doc.focusNodes.length ? doc.focusNodes : phase.nodes,
       phaseCompetencies: phase.competencies,
       focusUntil: doc.focusUntil, focusExpired: Boolean(doc.focusUntil && doc.focusUntil < dateOf(now)),
@@ -127,7 +131,8 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
       evidenceCount: catalog.filter((entry) => phase.nodes.includes(entry.node) || phase.competencies.includes(entry.competency)).length,
       evidenceTruncated: catalog.filter((entry) => phase.nodes.includes(entry.node) || phase.competencies.includes(entry.competency)).length > 200,
       missingPrerequisites,
-      missingFreshEvidence: doc.version === 2 ? missingFreshEvidence(phase, catalog, doc.entryEvidenceRefs, dateOf(() => new Date(doc.enteredAt)), doc.entryEvidenceEvents) : [...phase.nodes],
+      missingFreshEvidence: phase.kind === 'training' && phase.exitChecks.length ? exitCheckResults.filter((check) => !check.passed).map((check) => check.target)
+        : doc.version >= 2 ? missingFreshEvidence(phase, catalog, doc.entryEvidenceRefs, dateOf(() => new Date(doc.enteredAt)), doc.entryEvidenceEvents, dateOf(now), doc.enteredAt, now().toISOString()) : [...phase.nodes],
       ...budget(doc),
     }
   }
@@ -139,7 +144,9 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
       if (action === 'assess') {
         const requested = args.evidenceNodes
         if (requested !== undefined && (!Array.isArray(requested) || requested.some((node) => typeof node !== 'string' || !loadMap().byId.has(node)))) throw new Error('evidenceNodes 必须是地图节点数组。')
-        const catalog = evidence().filter((entry) => !requested?.length || requested.includes(entry.node))
+        const events = args.evidenceEventIds
+        if (events !== undefined && (!Array.isArray(events) || events.some((event) => typeof event !== 'string' || !event.trim()))) throw new Error('evidenceEventIds 必须是非空场次 eventId 字符串组成的数组。')
+        const catalog = evidence().filter((entry) => (!requested?.length || requested.includes(entry.node)) && (!events?.length || events.includes(entry.eventId)))
         return { ...snapshot(old), evidence: catalog.slice(-200), evidenceCount: catalog.length, evidenceTruncated: catalog.length > 200 }
       }
       if (!['create', 'revise', 'advance'].includes(action)) throw new Error('action 只能是 assess/read/create/revise/advance。')
@@ -152,7 +159,7 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
       if (action === 'create') {
         if (old?.status === 'active') throw new Error('已有有效路线，请 revise；不能用 create 悄悄替换正在执行的课程。')
         doc = {
-          version: 2, goal: clean(args.goal), baseline: clean(args.baseline),
+          version: 3, goal: clean(args.goal), baseline: clean(args.baseline),
           weeklyHours: args.weeklyHours ?? 0, deadline: clean(args.deadline),
           phases: normalizePhases(args.phases, byId), current: 0, status: 'active',
           focusNodes: [], focusUntil: '', history: old?.history ?? [],
@@ -164,6 +171,7 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
         if (action === 'advance') {
           const state = snapshot(old)
           if (state.needsReview) throw new Error(state.planningWarnings.join('；'))
+          if (state.exitCheckResults.some((check) => !check.passed)) throw new Error(`阶段结构化验收未通过：${state.exitCheckResults.filter((check) => !check.passed).map((check) => `${check.target}（${check.missing.join('，')}）`).join('；')}。只有符合条件的新成功事实计数，不能复用旧事件。`)
           if (state.missingFreshEvidence.length) throw new Error(`本阶段尚缺新${old.phases[old.current].kind === 'diagnostic' ? '诊断' : '独立完成或过卷'}记录：${state.missingFreshEvidence.join('、')}。不能复用进入阶段之前的记录。`)
           if (state.missingVerified.length) throw new Error(`阶段还缺检测证据：${state.missingVerified.join('、')}。不会按日历自动推进。`)
           if (state.pendingNodes.length) throw new Error('当前阶段还有押着的动作，先完成或撤销，再决定推进。')
@@ -191,7 +199,7 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
               throw new Error('当前诊断不能通过 revise 改成训练或删掉待诊断节点；先产生新记录，再 advance。')
             }
             doc.phases = phases
-            const workKeys = ['kind', 'nodes', 'competencies', 'outcome', 'exitCriteria', 'basis', 'finding', 'evidenceRefs']
+            const workKeys = ['kind', 'nodes', 'competencies', 'outcome', 'exitCriteria', 'exitChecks', 'basis', 'finding', 'evidenceRefs']
             if (old.version === 1 || workKeys.some((key) => JSON.stringify(doc.phases[doc.current][key]) !== JSON.stringify(old.phases[old.current][key]))) enter(doc, catalog)
           }
         }
@@ -206,7 +214,7 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
       if (new Set(doc.focusNodes).size !== doc.focusNodes.length || doc.focusNodes.some((n) => !doc.phases[doc.current].nodes.includes(n))) throw new Error('本周主线必须属于当前阶段，不能直接跳到未来阶段。')
       if (!validDate(doc.focusUntil)) throw new Error('focusUntil 必须为空或真实的 YYYY-MM-DD 日期。')
       validatePlan(doc.phases, { byId, progress: loadProgress(), catalog, current: doc.current })
-      doc.version = 2
+      doc.version = 3
       doc.revision = (old?.revision ?? 0) + 1
       doc.updated = now().toISOString()
       const previous = old ? { ...old } : null
@@ -251,6 +259,8 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
         `- 主线节点：${state.focusNodes.join('、') || '由比赛能力证据驱动'}`,
         state.phaseCompetencies.length ? `- 阶段比赛能力：${state.phaseCompetencies.join('、')}` : '',
         `- 阶段验收：${state.exitCriteria}`,
+        ...state.exitCheckResults.map((check) => `- 结构化验收 ${check.target}：${check.passed ? '已满足' : check.missing.join('；')}；只证明这些条件下的表现，不代表永久掌握。`),
+        ...state.evidencePrecisionWarnings.map((warning) => `- 证据精度：${warning}`),
         `- 阶段编排依据：${state.roadmap.find((phase) => phase.active)?.basis ?? ''}`,
         ...state.planningWarnings.map((warning) => `- 编排待核查：${warning}`),
         ...state.budgetWarnings.map((warning) => `- 时间预算：${warning}`),
@@ -265,10 +275,19 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
 }
 
 const stringList = { type: 'array', items: { type: 'string' } }
+const exitCheckProperties = {
+  node: { type: 'string' }, competency: { type: 'string' },
+  minEvents: { type: 'integer', required: true, description: '不同新成功事件的最少次数；进入阶段前的事件不计。' },
+  minDistinctDays: { type: 'integer', description: '至少跨几个不同日期，1–minEvents；2表示跨日复测。' },
+  independent: { type: 'boolean', description: '必须有明确相符的独立性事实，不从说明推测。' },
+  maxMinutes: { type: 'number', description: '每个合格事件的最大用时，必须有真实数值。' },
+  metric: { type: 'string', description: '待检查的事实指标名，需与maxValue一起填。' }, maxValue: { type: 'number' },
+}
+const exitChecksSchema = { type: 'array', items: { type: 'object', additionalProperties: false, properties: exitCheckProperties } }
 const phaseProperties = {
   id: { type: 'string', required: true }, title: { type: 'string', required: true },
   outcome: { type: 'string', required: true }, nodes: stringList, competencies: stringList,
-  exitCriteria: { type: 'string', required: true }, requiredVerified: stringList,
+  exitCriteria: { type: 'string', required: true }, exitChecks: { ...exitChecksSchema, description: 'training必须覆盖每个节点/能力的结构化验收；文字验收不能代替次数、跨日、独立性、用时或事实指标。' }, requiredVerified: stringList,
   kind: { type: 'string', required: true, enum: ['diagnostic', 'training', 'provisional', 'legacy'], description: '诊断/有证据训练/远期待定；legacy只用于保留已完成历史。' },
   finding: { type: 'string', required: true, enum: ['gap', 'extension', 'unknown'] },
   basis: { type: 'string', required: true, description: '具体观察或待确认问题，至少10字。' },
@@ -283,10 +302,11 @@ export function curriculumTool(store) {
   const required = (type) => ({ type, required: true })
   return {
     name: 'coach_curriculum',
-    description: '按真实记录编排长期课程：assess取检测/判因/训练/VP的证据id；read查看路线；create建立；revise按证据调整；advance验收后推进。阶段可绑定地图节点，也可只绑定比赛能力（读题、决策、团队沟通）；训练阶段必须有对应真实短板或进阶起点，并按显式前置与必验阶段排序；无依据先diagnostic，远期可provisional但不能直接执行。阶段需目标贡献、优先级理由、时间估算。写操作带expectedRevision和reason；诊断/训练验收都需进入阶段后的新事件，不能复用旧记录。',
+    description: '按真实记录编排长期课程：assess取检测/判因/训练/VP的证据id，可用evidenceEventIds精确查询某场历史VP，避免200条返回截断；read查看路线；create建立；revise按证据调整；advance验收后推进。阶段可绑定地图节点，也可只绑定比赛能力（读题、决策、团队沟通）；训练阶段必须有对应真实短板或进阶起点，并按显式前置与必验阶段排序；无依据先diagnostic，远期可provisional但不能直接执行。阶段需目标贡献、优先级理由、时间估算。写操作带expectedRevision和reason；诊断/训练验收都需进入阶段后的新事件，不能复用旧记录。',
     parameters: {
       action: { type: 'string', required: true, enum: ['assess', 'read', 'create', 'revise', 'advance'] },
-      evidenceNodes: { ...stringList, description: 'assess可按地图节点过滤；最多返回200条，截断时缩小节点范围。' },
+      evidenceNodes: { ...stringList, description: 'assess可按地图节点过滤；最多返回200条，截断时缩小节点或场次范围。' },
+      evidenceEventIds: { ...stringList, description: 'assess按真实场次eventId精确过滤，先筛选再取最后200条；可读取较早VP的未标注能力事实。与evidenceNodes同时填写时取交集；空数组不限场次，不影响阶段全量验收。' },
       expectedRevision: { type: 'integer', description: 'read 返回的版本；首次 create 为 0。' },
       goal: { type: 'string', description: '长期能力目标。' }, baseline: { type: 'string', description: '已核实的起点和待确认信息，不能猜测。' },
       weeklyHours: { type: 'number', description: '每周可用小时；0 表示未确认。' }, deadline: { type: 'string', description: '目标日期 YYYY-MM-DD，可留空。' },
@@ -305,10 +325,16 @@ export function curriculumTool(store) {
         missingVerified: { ...stringList, required: true }, pendingNodes: { ...stringList, required: true },
         needsReview: required('boolean'), planningWarnings: { ...stringList, required: true },
         missingPrerequisites: { ...stringList, required: true }, missingFreshEvidence: { ...stringList, required: true },
+        evidencePrecisionWarnings: { ...stringList, required: true },
+        exitChecks: { ...exitChecksSchema, required: true },
+        exitCheckResults: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: {
+          ...exitCheckProperties, target: required('string'), matchedEvents: required('integer'), distinctDays: required('integer'), passed: required('boolean'), missing: { ...stringList, required: true },
+        } } },
         evidenceCount: required('integer'), evidenceTruncated: required('boolean'),
         remainingEstimatedHours: required('number'), estimatedWeeks: required('number'), budgetWarnings: { ...stringList, required: true },
         evidence: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties:
-          { ...Object.fromEntries(['id', 'eventId', 'source', 'node', 'date', 'signal', 'summary', 'fingerprint'].map((key) => [key, required('string')])), competency: { type: 'string' } } } },
+          { ...Object.fromEntries(['id', 'eventId', 'source', 'node', 'date', 'signal', 'summary', 'fingerprint'].map((key) => [key, required('string')])), competency: { type: 'string' },
+            independent: { type: 'boolean' }, minutes: { type: 'number' }, metric: { type: 'string' }, value: { type: 'number' }, teamMode: { type: 'string' }, transfer: { type: 'boolean' }, occurredAt: { type: 'string' } } } },
         roadmap: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: {
           ...phaseProperties, nodes: { ...stringList, required: true }, competencies: { ...stringList, required: true }, requiredVerified: { ...stringList, required: true }, position: required('integer'), active: required('boolean'),
           prerequisites: { ...stringList, required: true },
@@ -321,13 +347,15 @@ export function curriculumTool(store) {
       render: (args, state) => [{ type: 'text', text: !state.ok ? `❌ 课程未更新：${state.reject}`
         : args?.action === 'assess' ? ['【实际编排依据】',
           ...state.evidence.map((entry) => `${entry.id}\n  ${entry.date} ${entry.node || entry.competency} · ${entry.signal} · ${entry.summary}`),
-          state.evidenceCount ? `共${state.evidenceCount}条${state.evidenceTruncated ? '，仅返回最后200条；按evidenceNodes缩小范围' : ''}` : '没有可用记录。先建立诊断阶段，不凭rating或状态断言短板。',
+          state.evidenceCount ? `共${state.evidenceCount}条${state.evidenceTruncated ? '，仅返回最后200条；按evidenceNodes或evidenceEventIds缩小范围' : ''}` : '没有可用记录。先建立诊断阶段，不凭rating或状态断言短板。',
           ...state.planningWarnings,
         ].join('\n')
         : !state.exists ? '尚无长期课程。先assess核查真实记录；缺依据先diagnostic，未来假设用provisional。'
           : [`【长期课程 · 版本 ${state.revision} · ${state.status}】${state.goal}`,
             ...state.roadmap.map((p) => `${p.active ? '▶ ' : ''}${p.position}. ${p.title} [${p.kind}]：${p.outcome}\n  依据：${p.basis}\n  排序：${p.priorityReason}；预计${p.estimatedHours}小时`),
             `当前主线：${state.focusNodes.join('、') || '能力证据驱动'}`, state.phaseCompetencies.length ? `阶段比赛能力：${state.phaseCompetencies.join('、')}` : '', `验收：${state.exitCriteria}`,
+            ...state.exitCheckResults.map((check) => `结构化验收 ${check.target}：${check.passed ? `合格事件${check.matchedEvents}次，跨${check.distinctDays}日；仅证明本次条件下达到要求` : check.missing.join('；')}`),
+            ...state.evidencePrecisionWarnings.map((warning) => `证据精度：${warning}`),
             state.missingVerified.length ? `必验缺口：${state.missingVerified.join('、')}` : '必验节点已有记录；仍需判断能力成果是否达到，不能自动推进。',
             state.pendingNodes.length ? `先完成当前单元：${state.pendingNodes.join('、')}` : '',
             state.focusExpired ? '本周主线到期，先复盘并修订。' : '',

package/lib/strategy.js

@@ -2,11 +2,17 @@
 // It stores contest targets, VP evidence and postmortems separately from
 // PROGRESS.yaml so the existing knowledge workflow keeps its meaning.
 import { copyFileSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
+import { dirname, join } from 'node:path'
 import { parse, stringify } from 'yaml'
+import { createHash } from 'node:crypto'
+import { validOccurredAt } from './curriculum-evidence.js'
 
 const clean = (value) => String(value ?? '').trim()
 const asArray = (value) => Array.isArray(value) ? value : []
+const accepted = new Set(['AC', 'OK', 'ACCEPTED', 'SOLVED'])
+const localDay = (value) => `${value.getFullYear()}-${String(value.getMonth() + 1).padStart(2, '0')}-${String(value.getDate()).padStart(2, '0')}`
+const nonnegative = (value, integer = false) => value === undefined ||
+  (typeof value === 'number' && Number.isFinite(value) && value >= 0 && (!integer || Number.isInteger(value)))
 const isoDay = (value) => {
   const day = clean(value)
   if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) return ''
@@ -14,7 +20,7 @@ const isoDay = (value) => {
   return Number.isFinite(d.getTime()) && d.toISOString().slice(0, 10) === day ? day : ''
 }
 
-const emptyTarget = () => ({ version: 1, revision: 0, updated: '', contest: '', date: '', result: '', teamMode: 'solo', weeklyHours: 0, constraints: {}, priorities: [] })
+const emptyTarget = () => ({ version: 1, revision: 0, updated: '', contest: '', date: '', result: '', teamMode: 'solo', weeklyHours: 0, profileId: '', constraints: {}, priorities: [] })
 const emptyVp = () => ({ version: 1, revision: 0, updated: '', events: [], postmortems: [] })
 
 function readYaml(path, fallback) {
@@ -59,32 +65,51 @@ function normalizeProblem(value) {
   if (!value || typeof value !== 'object') return null
   const problemId = clean(value.problemId || value.id)
   if (!problemId) return null
+  if (!nonnegative(value.readMinutes) || !nonnegative(value.solveMinutes ?? value.elapsedMinutes) || !nonnegative(value.attempts, true) ||
+      (value.independent !== undefined && typeof value.independent !== 'boolean') ||
+      (value.occurredAt !== undefined && !validOccurredAt(value.occurredAt))) return null
   const status = clean(value.status || value.verdict || 'unknown').toUpperCase()
   return {
     problemId,
     status,
-    readMinutes: Math.max(0, Number(value.readMinutes) || 0),
-    solveMinutes: Math.max(0, Number(value.solveMinutes ?? value.elapsedMinutes) || 0),
-    attempts: Math.max(0, Math.trunc(Number(value.attempts) || 0)),
+    readMinutes: value.readMinutes ?? 0,
+    solveMinutes: value.solveMinutes ?? value.elapsedMinutes ?? 0,
+    attempts: value.attempts ?? 0,
     competencies: asArray(value.competencies || value.skills).map(clean).filter(Boolean).slice(0, 12),
     note: clean(value.note),
+    ...(typeof value.independent === 'boolean' ? { independent: value.independent } : {}),
+    ...(typeof value.occurredAt === 'string' && Number.isFinite(Date.parse(value.occurredAt)) ? { occurredAt: value.occurredAt } : {}),
   }
 }
 
+function normalizeMeasurement(value) {
+  if (!value || typeof value !== 'object' || !clean(value.competency) || !clean(value.metric) ||
+      typeof value.value !== 'number' || !Number.isFinite(value.value) || typeof value.passed !== 'boolean' ||
+      (value.independent !== undefined && typeof value.independent !== 'boolean') ||
+      (value.occurredAt !== undefined && !validOccurredAt(value.occurredAt))) return null
+  return { competency: clean(value.competency), metric: clean(value.metric), value: value.value, passed: value.passed,
+    ...(value.independent !== undefined ? { independent: value.independent } : {}),
+    ...(value.occurredAt !== undefined ? { occurredAt: value.occurredAt } : {}) }
+}
+
 function normalizeEvent(value) {
   if (!value || typeof value !== 'object') return null
   const eventId = clean(value.eventId || value.id)
   const contest = clean(value.contest || value.contestId)
   const date = isoDay(value.date || value.startedAt?.slice?.(0, 10))
-  const durationMinutes = Math.max(0, Math.trunc(Number(value.durationMinutes) || 0))
-  const problems = asArray(value.problems).map(normalizeProblem).filter(Boolean)
-  if (!eventId || !contest || !date || !problems.length) return null
+  const durationMinutes = value.durationMinutes ?? 0
+  const problems = asArray(value.problems).map(normalizeProblem)
+  const measurements = asArray(value.measurements).map(normalizeMeasurement)
+  if (!eventId || !contest || !date || !nonnegative(durationMinutes, true) || !problems.length || problems.some(problem => !problem) ||
+      (value.measurements !== undefined && (!Array.isArray(value.measurements) || measurements.some(item => !item) ||
+       new Set(measurements.map(item => `${item.competency}:${item.metric}`)).size !== measurements.length))) return null
   return {
     eventId, contest, date, durationMinutes,
     virtual: value.virtual !== false,
     teamMode: clean(value.teamMode || 'solo'),
     problems,
     note: clean(value.note),
+    ...(value.measurements !== undefined ? { measurements } : {}),
   }
 }
 
@@ -102,12 +127,44 @@ function normalizePostmortem(value) {
     rootCauses: asArray(value.rootCauses).map(clean).filter(Boolean).slice(0, 20),
     nextActions: asArray(value.nextActions).map(clean).filter(Boolean).slice(0, 20),
     note: clean(value.note),
+    findings: asArray(value.findings).map(finding => ({ competency: clean(finding?.competency),
+      status: clean(finding?.status), cause: clean(finding?.cause), evidenceRefs: asArray(finding?.evidenceRefs).map(clean) })),
+  }
+}
+
+function vpFacts(vp) {
+  const result = []
+  for (const event of vp.events) for (const input of event.problems) {
+    const problem = normalizeProblem(input)
+    const hash = createHash('sha256').update(JSON.stringify({ eventId: event.eventId, date: event.date, teamMode: event.teamMode, problem })).digest('hex')
+    for (const competency of new Set(problem.competencies.length ? problem.competencies : [''])) {
+      const id = `vp:${encodeURIComponent(event.eventId)}:${encodeURIComponent(problem.problemId)}:${encodeURIComponent(competency)}:${hash}`
+      result.push({ id, eventId: event.eventId, source: 'vp', node: '', competency, date: event.date,
+        signal: accepted.has(problem.status) && problem.independent === true ? 'baseline' : 'observation',
+        summary: `${problem.problemId} ${problem.status} · ${competency}`, fingerprint: hash,
+        ...(typeof problem.independent === 'boolean' ? { independent: problem.independent } : {}),
+        ...(problem.solveMinutes > 0 ? { minutes: problem.solveMinutes } : {}),
+        ...(problem.occurredAt ? { occurredAt: problem.occurredAt } : {}), teamMode: event.teamMode })
+    }
+  }
+  for (const event of vp.events) for (const measurement of event.measurements ?? []) {
+    const hash = createHash('sha256').update(JSON.stringify({ eventId: event.eventId, date: event.date, teamMode: event.teamMode, measurement })).digest('hex')
+    result.push({ id: `vp-metric:${encodeURIComponent(event.eventId)}:${encodeURIComponent(measurement.metric)}:${hash}`,
+      eventId: event.eventId, source: 'vp', node: '', competency: measurement.competency, date: event.date,
+      signal: measurement.passed && measurement.independent === true ? 'baseline' : 'observation',
+      summary: `${measurement.metric} = ${measurement.value}（${measurement.passed ? '已验收' : '仅观察'}）`, fingerprint: hash,
+      metric: measurement.metric, value: measurement.value, teamMode: event.teamMode,
+      ...(measurement.independent !== undefined ? { independent: measurement.independent } : {}),
+      ...(measurement.occurredAt !== undefined ? { occurredAt: measurement.occurredAt } : {}) })
   }
+  return result
 }
 
-export function createStrategyStore({ dataDir, competenciesPath, now = () => new Date() }) {
+export function createStrategyStore({ dataDir, vpDir = dataDir, competenciesPath,
+  nodeScopesPath = join(dirname(competenciesPath), 'NODE_SCOPES.yaml'),
+  contestProfilesPath = join(dirname(competenciesPath), 'CONTEST_PROFILES.yaml'), now = () => new Date() }) {
   const targetPath = join(dataDir, 'TARGET.yaml')
-  const vpPath = join(dataDir, 'VP_EVENTS.yaml')
+  const vpPath = join(vpDir, 'VP_EVENTS.yaml')
   const validateTarget = (doc) => {
     const errors = []
     if (doc.version !== 1) errors.push('version 必须是 1')
@@ -142,19 +199,24 @@ export function createStrategyStore({ dataDir, competenciesPath, now = () => new
   const saveTarget = (doc) => writeYaml(targetPath, '# TARGET.yaml — 比赛目标与能力优先级\n', doc)
   const saveVp = (doc) => writeYaml(vpPath, '# VP_EVENTS.yaml — VP 记录与赛后复盘\n', doc)
   const loadCompetencies = () => readYaml(competenciesPath, () => ({ version: 1, competencies: [] })).competencies ?? []
+  const loadProfiles = () => readYaml(contestProfilesPath, () => ({ profiles: [] })).profiles ?? []
+  const profileFor = id => loadProfiles().find(item => item.id === id) ?? { id: '', title: '', scope: '', status: 'unselected',
+    sources: [], competencyIds: [], selectionGuidance: [], limitations: ['未选择比赛样本配置；不能把通用能力卡当作本场考纲。'] }
 
   function target(action = 'read', args = {}) {
     let old
     try { old = loadTarget() } catch (err) {
-      return { ok: false, reject: err.message, ...emptyTarget() }
+      return { ok: false, reject: err.message, ...emptyTarget(), availableProfiles: [] }
     }
-    if (action === 'read') return { ok: true, reject: '', ...old }
-    if (!['set', 'clear'].includes(action)) return { ok: false, reject: 'action 只能是 read/set/clear。', ...old }
+    const availableProfiles = action === 'profiles' ? loadProfiles() : []
+    old.availableProfiles = availableProfiles
+    if (['read', 'profiles'].includes(action)) return { ok: true, reject: '', ...old }
+    if (!['set', 'clear'].includes(action)) return { ok: false, reject: 'action 只能是 read/profiles/set/clear。', ...old }
     if (args.expectedRevision !== old.revision) return { ok: false, reject: '目标版本已变化；先 read，再按当前 revision 更新。', ...old }
     if (action === 'clear') {
       const next = { ...emptyTarget(), revision: old.revision + 1, updated: now().toISOString() }
       saveTarget(next)
-      return { ok: true, reject: '', ...next }
+      return { ok: true, reject: '', ...next, availableProfiles: [] }
     }
     const date = clean(args.date)
     if (!clean(args.contest) || !isoDay(date) || !clean(args.result)) return { ok: false, reject: 'set 必须提供 contest、真实 YYYY-MM-DD 的 date 和 result。', ...old }
@@ -169,26 +231,42 @@ export function createStrategyStore({ dataDir, competenciesPath, now = () => new
     if (unknown.length) return { ok: false, reject: `能力优先级没有范围卡片：${unknown.join('、')}。先补充 COMPETENCIES.yaml。`, ...old }
     const teamMode = clean(args.teamMode || old.teamMode || 'solo')
     if (!['solo', 'team'].includes(teamMode)) return { ok: false, reject: 'teamMode 只能是 solo 或 team。', ...old }
+    const profileId = args.profileId === undefined ? old.profileId : clean(args.profileId)
+    if (profileId && !loadProfiles().some(item => item.id === profileId)) return { ok: false, reject: 'profileId 不存在；先用 coach_target profiles 查看带出处的样本配置。', ...old }
+    if (args.constraints !== undefined && (!args.constraints || typeof args.constraints !== 'object' || Array.isArray(args.constraints))) return { ok: false, reject: 'constraints 必须是对象；不会修改现有目标。', ...old }
     const next = {
-      ...old, contest: clean(args.contest), date, result: clean(args.result),
+      ...old, contest: clean(args.contest), date, result: clean(args.result), profileId,
       teamMode, weeklyHours,
       constraints: args.constraints && typeof args.constraints === 'object' ? args.constraints : old.constraints,
       priorities, revision: old.revision + 1, updated: now().toISOString(),
     }
+    delete next.availableProfiles
     saveTarget(next)
-    return { ok: true, reject: '', ...next }
+    return { ok: true, reject: '', ...next, availableProfiles: [] }
   }
 
-  function vpImport(events = []) {
+  function vpImport(events = [], { source = 'manual' } = {}) {
     let old
     try { old = loadVp() } catch (err) {
       return { ok: false, reject: err.message, imported: 0, total: 0, revision: 0, events: [], invalid: [] }
     }
     if (!Array.isArray(events) || !events.length) return { ok: false, reject: '至少导入一场含题目记录的 VP；空数组不会修改现有数据。', imported: 0, total: old.events.length, revision: old.revision, events: old.events, invalid: ['events 为空'] }
-    const normalized = events.map(normalizeEvent)
-    const invalid = normalized.map((event, index) => event ? '' : `第 ${index + 1} 条 VP 记录缺 eventId/contest/date/problems`).filter(Boolean)
-    if (invalid.length) return { ok: false, reject: 'VP 导入被拒绝：' + invalid.join('；'), imported: 0, total: old.events.length, revision: old.revision, events: old.events, invalid }
     const existing = new Map(old.events.map((event) => [event.eventId, event]))
+    const inputs = events.map(event => {
+      const previous = existing.get(clean(event?.eventId || event?.id))
+      if (source !== 'sync' || !previous) return event
+      return { ...event, ...(previous.measurements ? { measurements: previous.measurements } : {}), problems: asArray(event.problems).map(problem => {
+        const prior = previous.problems.find(item => item.problemId === clean(problem?.problemId || problem?.id))
+        if (!prior) return problem
+        return { ...problem, competencies: prior.competencies, readMinutes: prior.readMinutes, note: prior.note,
+          ...(prior.independent !== undefined ? { independent: prior.independent } : {}) }
+      }) }
+    })
+    const normalized = inputs.map(normalizeEvent)
+    const known = new Set(loadCompetencies().map(item => item.id))
+    const invalid = normalized.map((event, index) => event && !(event.measurements ?? []).some(item => !known.has(item.competency)) ? '' :
+      `第 ${index + 1} 条 VP 记录有无效身份、日期、题目、数值或测量；用时非负，次数为整数，measurement需已知competency/metric/有限value/passed`).filter(Boolean)
+    if (invalid.length) return { ok: false, reject: 'VP 导入被拒绝：' + invalid.join('；'), imported: 0, total: old.events.length, revision: old.revision, events: old.events, invalid }
     for (const event of normalized) existing.set(event.eventId, event)
     const next = { ...old, events: [...existing.values()].sort((a, b) => `${a.date}|${a.eventId}`.localeCompare(`${b.date}|${b.eventId}`)), revision: old.revision + 1, updated: now().toISOString() }
     saveVp(next)
@@ -198,9 +276,27 @@ export function createStrategyStore({ dataDir, competenciesPath, now = () => new
   function postmortem(value) {
     const eventId = clean(value?.eventId)
     const vp = loadVp()
-    if (!vp.events.some((event) => event.eventId === eventId)) return { ok: false, reject: `找不到 VP「${eventId}」，先导入这场 VP。`, postmortems: vp.postmortems }
+    const reject = message => ({ ok: false, reject: message, eventId, revision: vp.revision, postmortems: vp.postmortems })
+    const event = vp.events.find(event => event.eventId === eventId)
+    if (!event) return reject(`找不到 VP「${eventId}」，先导入这场 VP。`)
     const record = normalizePostmortem(value)
-    if (!record || (!record.competencies.length && !record.rootCauses.length && !record.nextActions.length)) return { ok: false, reject: '复盘至少要写 competencies、rootCauses 或 nextActions 之一。', postmortems: vp.postmortems }
+    if (!record || (!record.competencies.length && !record.rootCauses.length && !record.nextActions.length && !record.findings.length)) return reject('复盘至少要写 findings、competencies、rootCauses 或 nextActions 之一。')
+    if (value.findings !== undefined && (!Array.isArray(value.findings) || value.findings.length > 30)) return reject('findings 必须是最多30条结论的数组。')
+    const facts = vpFacts(vp)
+    const known = new Set(loadCompetencies().map(item => item.id))
+    const seen = new Set()
+    for (const finding of record.findings) {
+      if (!known.has(finding.competency) || seen.has(finding.competency)) return reject('每项 finding 必须对应已知且不重复的比赛能力。')
+      seen.add(finding.competency)
+      if (!['hypothesis', 'confirmed', 'resolved'].includes(finding.status) || finding.cause.length < 10) return reject('finding 需 hypothesis/confirmed/resolved 和至少10字的具体原因；未确认时只用 hypothesis。')
+      if (!Array.isArray(value.findings.find(item => item?.competency === finding.competency)?.evidenceRefs) ||
+          new Set(finding.evidenceRefs).size !== finding.evidenceRefs.length || !finding.evidenceRefs.length) return reject('finding 必须引用不重复的事实 evidenceRefs；先 coach_curriculum assess 取引用。')
+      const cited = finding.evidenceRefs.map(id => facts.find(fact => fact.id === id && fact.eventId === eventId && (!fact.competency || fact.competency === finding.competency)))
+      if (cited.some(fact => !fact)) return reject('finding 引用了不存在、已变化、其它场次或无关能力的事实。')
+      if (finding.status === 'resolved' && !cited.some(fact => fact.signal === 'baseline')) return reject('resolved 需要真实独立成功的记录，不能把猜测或失败改成成功。')
+    }
+    // A retrospective is dated by its observed event, not by the day somebody edits it.
+    record.date = event.date
     const list = vp.postmortems.filter((item) => item.eventId !== eventId)
     list.push(record)
     const next = { ...vp, postmortems: list, revision: vp.revision + 1, updated: now().toISOString() }
@@ -216,37 +312,44 @@ export function createStrategyStore({ dataDir, competenciesPath, now = () => new
     } catch (err) {
       return {
         ok: false, reject: err.message, contest: '', deadline: '', focus: [], postponed: [],
-        evidenceEvents: 0, postmortems: 0,
+        evidenceEvents: 0, postmortems: 0, profile: profileFor(''), daysRemaining: 0,
       }
     }
     const catalog = loadCompetencies()
     if (!targetDoc.contest) return {
       ok: false, reject: '还没有比赛目标，先用 coach_target set。', contest: '', deadline: '',
-      focus: [], postponed: [], evidenceEvents: vp.events.length, postmortems: vp.postmortems.length,
-    }
-    const postmortemHits = new Map()
-    for (const record of vp.postmortems) for (const id of [...record.competencies, ...record.rootCauses]) postmortemHits.set(id, (postmortemHits.get(id) ?? 0) + 1)
-    const problemHits = new Map()
-    for (const event of vp.events) {
-      for (const id of new Set(event.problems.flatMap((problem) => problem.competencies))) {
-        problemHits.set(id, (problemHits.get(id) ?? 0) + 1)
-      }
+      focus: [], postponed: [], evidenceEvents: vp.events.length, postmortems: vp.postmortems.length, profile: profileFor(''), daysRemaining: 0,
     }
+    const day = localDay(now())
+    const cutoff = new Date(Date.parse(`${day}T12:00:00Z`) - 29 * 86400000).toISOString().slice(0, 10)
+    const recent = evidence().evidence.filter(entry => entry.date >= cutoff && entry.date <= day)
     const focus = targetDoc.priorities.map((priority) => {
       const meta = catalog.find((item) => item.id === priority.id) ?? { id: priority.id, title: priority.id, contestUse: '暂无比赛能力卡片，先补充定义。', nodes: [] }
-      const evidence = (postmortemHits.get(priority.id) ?? 0) + (problemHits.get(priority.id) ?? 0)
-      const urgency = Math.max(1, 30 - Math.floor((Date.parse(`${targetDoc.date}T12:00:00Z`) - Date.now()) / 86400000))
-      const score = Math.round(priority.weight * (1 + evidence) * urgency / 10) / 10
-      return { id: priority.id, title: meta.title ?? priority.id, score, evidenceCount: evidence, contestUse: meta.contestUse ?? '', nodes: meta.nodes ?? [], whyNow: evidence ? `最近复盘出现 ${evidence} 次相关问题；优先修复它。` : (priority.reason || '它是目标中的高权重能力，目前缺少 VP 证据。') }
+      const entries = recent.filter(entry => entry.competency === priority.id)
+      const count = signal => new Set(entries.filter(entry => entry.signal === signal).map(entry => entry.eventId)).size
+      const gapCount = count('gap'), baselineCount = count('baseline'), observationCount = count('observation')
+      const evidenceCount = new Set(entries.map(entry => entry.eventId)).size
+      const score = priority.weight * (1 + gapCount)
+      const whyNow = gapCount ? `近30天有 ${gapCount} 场已确认的相关短板；结合目标权重优先处理。`
+        : baselineCount ? `近30天有 ${baselineCount} 场独立完成的能力起点；不是待修复问题，是否进阶需核对迁移与限时表现。`
+          : observationCount ? `近30天有 ${observationCount} 场相关观察，原因尚待确认；先诊断，不能直接安排补短板。`
+            : (priority.reason || '它是目标中的高权重能力，目前缺少近期 VP 证据；先取证。')
+      return { id: priority.id, title: meta.title ?? priority.id, score, evidenceCount, gapCount, baselineCount, observationCount,
+        evidenceRefs: entries.map(entry => entry.id), contestUse: meta.contestUse ?? '', nodes: meta.nodes ?? [], whyNow }
     }).sort((a, b) => b.score - a.score)
-    return { ok: true, reject: '', contest: targetDoc.contest, deadline: targetDoc.date, focus: focus.slice(0, 3), postponed: focus.slice(3).map((item) => item.id), evidenceEvents: vp.events.length, postmortems: vp.postmortems.length }
+    const daysRemaining = Math.round((Date.parse(`${targetDoc.date}T12:00:00Z`) - Date.parse(`${day}T12:00:00Z`)) / 86400000)
+    return { ok: true, reject: '', contest: targetDoc.contest, deadline: targetDoc.date, focus: focus.slice(0, 3), postponed: focus.slice(3).map((item) => item.id),
+      evidenceEvents: vp.events.length, postmortems: vp.postmortems.length, profile: profileFor(targetDoc.profileId), daysRemaining }
   }
 
   function scope(nodeOrId) {
     const catalog = loadCompetencies()
-    const direct = catalog.find((item) => item.id === nodeOrId || item.nodes?.includes(nodeOrId))
-    if (direct) return { ok: true, reject: '', found: true, ...direct }
-    return { ok: false, reject: `「${nodeOrId}」还没有范围卡片，不能凭空编造适用范围；先补充 COMPETENCIES.yaml。`, found: false, id: nodeOrId, title: nodeOrId, contestUse: '', nodes: [], appliesTo: [], extensions: [], notFor: [], commonFailures: [], transferProblems: [], exitEvidence: [] }
+    const nodeCards = readYaml(nodeScopesPath, () => ({ nodes: [] })).nodes ?? []
+    const direct = nodeCards.find(item => item.id === nodeOrId) ?? catalog.find(item => item.id === nodeOrId || item.nodes?.includes(nodeOrId))
+    const base = { id: nodeOrId, title: nodeOrId, contestUse: '', nodes: [], appliesTo: [], extensions: [], notFor: [],
+      commonFailures: [], transferProblems: [], exitEvidence: [], recognition: [], proofQuestions: [], sources: [] }
+    if (direct) return { ok: true, reject: '', found: true, ...base, ...direct }
+    return { ok: false, reject: `「${nodeOrId}」还没有范围卡片，不能凭空编造适用范围；先补充 NODE_SCOPES.yaml 或 COMPETENCIES.yaml。`, found: false, ...base }
   }
 
   function route(nodeOrId, { purpose = 'progress', courseBound = false } = {}) {
@@ -271,20 +374,21 @@ export function createStrategyStore({ dataDir, competenciesPath, now = () => new
   function evidence() {
     try {
       const vp = loadVp()
-      const result = []
-      const baselineStatuses = new Set(['AC', 'OK', 'ACCEPTED', 'SOLVED'])
-      for (const event of vp.events) for (const problem of event.problems) {
-        const signal = baselineStatuses.has(problem.status) ? 'baseline' : 'gap'
-        for (const competency of new Set(problem.competencies)) {
-          const id = `vp:${event.eventId}:${problem.problemId}:${competency}`
-          result.push({ id, eventId: event.eventId, source: 'vp', node: '', competency,
-            date: event.date, signal, summary: `${problem.problemId} ${problem.status} · ${competency}`, fingerprint: id })
-        }
-      }
+      const result = vpFacts(vp)
       for (const record of vp.postmortems) for (const competency of new Set(record.competencies)) {
         const id = `postmortem:${record.eventId}:${competency}`
         result.push({ id, eventId: record.eventId, source: 'postmortem', node: '', competency,
-          date: record.date, signal: 'gap', summary: `复盘指出 ${competency}`, fingerprint: id })
+          date: record.date, signal: 'observation', summary: `复盘提及 ${competency}，原因尚待核实`, fingerprint: id })
+      }
+      const facts = new Map(result.filter(entry => entry.source === 'vp').map(entry => [entry.id, entry]))
+      for (const record of vp.postmortems) for (const finding of record.findings ?? []) {
+        const cited = finding.evidenceRefs.map(id => facts.get(id))
+        if (!cited.length || cited.some(fact => !fact || fact.eventId !== record.eventId || (fact.competency && fact.competency !== finding.competency))) continue
+        const hash = createHash('sha256').update(JSON.stringify(finding)).digest('hex')
+        result.push({ id: `finding:${encodeURIComponent(record.eventId)}:${finding.competency}:${hash}`, eventId: record.eventId,
+          source: 'postmortem', node: '', competency: finding.competency, date: cited[0].date,
+          signal: finding.status === 'confirmed' ? 'gap' : 'observation',
+          summary: `${finding.status === 'confirmed' ? '复盘已确认' : finding.status === 'resolved' ? '复盘已解决' : '待确认假设'}：${finding.cause}`, fingerprint: hash })
       }
       return { ok: true, reject: '', evidence: result }
     } catch (err) { return { ok: false, reject: err.message, evidence: [] } }
@@ -296,10 +400,14 @@ export function createStrategyStore({ dataDir, competenciesPath, now = () => new
     const f = focus()
     return [
       `- 比赛目标：${t.contest}，目标日期 ${t.date}，结果目标 ${t.result}，团队模式 ${t.teamMode}`,
+      `- 距目标日期：${f.daysRemaining}天；剩余时间影响训练取舍，不能只给所有能力乘同一紧急系数。`,
+      `- 比赛样本配置：${f.profile.title || '尚未选择'}（${f.profile.status}）；${f.profile.limitations.join('；')}`,
       `- 当前目标权重：${t.priorities.map((p) => `${p.id}(${p.weight})`).join('、')}`,
       f.focus?.length ? `- 本轮优先能力：${f.focus.map((x) => `${x.title}（${x.whyNow}）`).join('；')}` : '- 当前没有可计算的能力重点。',
       f.postponed?.length ? `- 暂缓能力：${f.postponed.join('、')}` : '',
       '- 每次布置前先说明它服务哪个比赛能力、适用范围、迁移题和退出条件。',
+      '- 重点排序是目标权重与近30天已确认问题的参考；不是掌握度或金牌概率。先区分观察、假设、确认结论。',
+      '- 按长期能力目标→本次比赛目标→当前阶段→今天一个动作解释取舍；临近比赛不擅自覆盖长期目标。',
     ].filter(Boolean).join('\n')
   }
 

package/lib/vp-client.js

@@ -124,10 +124,22 @@ export function createVpClient({ dataDir, fetchImpl = globalThis.fetch, now = ()
       const payload = await request(current.baseUrl, `/api/coach/sync?${query}`, { token: current.token })
       const account = verifyAccount(current, payload.account)
       const next = payload.next_cursor || cursor
-      atomicJson(join(accountDir(current.id), 'SYNC.json'), { ...payload, account, synced_at: now().toISOString() })
+      const cachePath = join(accountDir(current.id), 'SYNC.json')
+      let cached = {}
+      try { cached = JSON.parse(readFileSync(cachePath, 'utf8')); verifyAccount(current, cached.account) }
+      catch (err) { if (err.code !== 'ENOENT') throw err }
+      const combined = { ...payload, account }
+      const pageCounts = {}
+      for (const key of ['submissions', 'events', 'contests']) {
+        pageCounts[key] = (payload[key] ?? []).length
+        const rows = new Map()
+        for (const row of [...(cached[key] ?? []), ...(payload[key] ?? [])]) rows.set(row.id, row)
+        combined[key] = [...rows.values()]
+      }
+      atomicJson(cachePath, { ...combined, synced_at: now().toISOString() })
       registry.accounts[String(current.id)] = { ...accountMeta, account, baseUrl: current.baseUrl, cursor: next, lastSyncAt: now().toISOString() }
       saveRegistry(registry)
-      return { ...payload, account, cursor: next, cachedPath: join(accountDir(current.id), 'SYNC.json') }
+      return { ...combined, cursor: next, hasMore: payload.has_more === true, pageCounts, cachedPath: cachePath }
     },
     async replay({ contestId, limit = 50000 } = {}) {
       const current = requireActive()