acmer-coach 2.3.1 → 2.5.0

package/lib/curriculum-planning.js

@@ -1,12 +1,46 @@
+import { validOccurredAt } from './curriculum-evidence.js'
+
 const clean = (value) => String(value ?? '').trim()
 const text = (value, field, phase) => {
   const result = clean(value)
   if (result.length < 10) throw new Error(`阶段 ${phase} 的 ${field} 需要至少 10 字的具体依据。`)
   return result
 }
-const coreKeys = ['id', 'title', 'outcome', 'nodes', 'competencies', 'exitCriteria', 'requiredVerified']
+const coreKeys = ['id', 'title', 'outcome', 'nodes', 'competencies', 'exitCriteria', 'exitChecks', 'requiredVerified']
 export const corePhase = (phase) => Object.fromEntries(coreKeys.map((key) => [key, phase[key]]))
 
+function normalizeExitChecks(input, phase) {
+  if (input === undefined) return []
+  if (!Array.isArray(input) || input.length > 100) throw new Error(`阶段 ${phase.id} 的 exitChecks 必须是最多 100 条的数组。`)
+  const targets = new Set()
+  return input.map((check) => {
+    const node = clean(check?.node), competency = clean(check?.competency)
+    if (Boolean(node) === Boolean(competency) || (node && !phase.nodes.includes(node)) || (competency && !phase.competencies.includes(competency))) throw new Error(`阶段 ${phase.id} 的 exitChecks 必须指定一个属于本阶段的 node 或 competency。`)
+    const target = `${node ? 'node' : 'competency'}:${node || competency}`
+    if (targets.has(target)) throw new Error(`阶段 ${phase.id} 的 exitChecks 目标不能重复：${node || competency}。`)
+    targets.add(target)
+    if (!Number.isInteger(check.minEvents) || check.minEvents < 1 || check.minEvents > 1000) throw new Error(`阶段 ${phase.id} 的 exitChecks.minEvents 应为 1–1000 的整数。`)
+    const result = { ...(node ? { node } : { competency }), minEvents: check.minEvents }
+    if (check.minDistinctDays !== undefined) {
+      if (!Number.isInteger(check.minDistinctDays) || check.minDistinctDays < 1 || check.minDistinctDays > check.minEvents) throw new Error(`阶段 ${phase.id} 的 minDistinctDays 应为 1–minEvents 的整数。`)
+      result.minDistinctDays = check.minDistinctDays
+    }
+    if (check.independent !== undefined) {
+      if (typeof check.independent !== 'boolean') throw new Error(`阶段 ${phase.id} 的 independent 必须是布尔值，不能从说明猜测。`)
+      result.independent = check.independent
+    }
+    if (check.maxMinutes !== undefined) {
+      if (!Number.isFinite(check.maxMinutes) || check.maxMinutes <= 0) throw new Error(`阶段 ${phase.id} 的 maxMinutes 必须为正数。`)
+      result.maxMinutes = check.maxMinutes
+    }
+    if (check.metric !== undefined || check.maxValue !== undefined) {
+      if (typeof check.metric !== 'string' || !check.metric.trim() || !Number.isFinite(check.maxValue)) throw new Error(`阶段 ${phase.id} 的 metric 与数值 maxValue 必须一起填写。`)
+      result.metric = check.metric.trim(); result.maxValue = check.maxValue
+    }
+    return result
+  })
+}
+
 export function prerequisitesOf(nodes, byId) {
   const result = new Set()
   const done = new Set()
@@ -29,7 +63,7 @@ export function prerequisitesOf(nodes, byId) {
   return [...result].sort()
 }
 
-export function normalizePhases(input, byId, { legacy = false, completed = [] } = {}) {
+export function normalizePhases(input, byId, { legacy = false, completed = [], allowMissingChecks = false } = {}) {
   if (!Array.isArray(input) || input.length < 1 || input.length > 30) throw new Error('课程需要 1–30 个阶段。')
   const ids = new Set()
   return input.map((phase, index) => {
@@ -42,6 +76,7 @@ export function normalizePhases(input, byId, { legacy = false, completed = [] }
       requiredVerified: Array.isArray(phase?.requiredVerified) ? phase.requiredVerified.map(clean)
         : (kind === 'training' || kind === 'legacy' ? [...(phase?.nodes ?? [])].map(clean) : []),
     }
+    p.exitChecks = normalizeExitChecks(phase?.exitChecks, p)
     if (!p.id || p.id.length > 80 || ids.has(p.id)) throw new Error('阶段 id 必须非空且唯一，最长 80 字符。')
     ids.add(p.id)
     if (!p.title || !p.outcome || !p.exitCriteria) throw new Error(`阶段 ${p.id} 缺标题、能力成果或验收条件。`)
@@ -52,7 +87,7 @@ export function normalizePhases(input, byId, { legacy = false, completed = [] }
     if (legacy) return { ...p, kind, finding: 'unknown', basis: '', goalContribution: '', priorityReason: '',
       estimatedHours: 0, evidenceRefs: [], uncertainty: '', diagnosticMethod: '', prerequisites }
     if (kind === 'legacy' && completed[index]?.kind === 'legacy' &&
-      JSON.stringify(corePhase(completed[index])) === JSON.stringify(p)) return { ...completed[index], prerequisites }
+      JSON.stringify(corePhase(completed[index])) === JSON.stringify(corePhase(p))) return { ...completed[index], prerequisites }
     if (!['diagnostic', 'training', 'provisional'].includes(kind)) throw new Error(`阶段 ${p.id} 必须声明 kind=diagnostic/training/provisional；旧路线需补齐编排依据。`)
     const finding = clean(phase.finding)
     if (kind === 'training' ? !['gap', 'extension'].includes(finding) : finding !== 'unknown') throw new Error(`阶段 ${p.id}：训练需声明 gap 或 extension；诊断/待定只能声明 unknown。`)
@@ -60,6 +95,10 @@ export function normalizePhases(input, byId, { legacy = false, completed = [] }
     const estimatedHours = phase.estimatedHours
     if (!Number.isFinite(estimatedHours) || estimatedHours < 0 || estimatedHours > 10000 || (kind !== 'provisional' && estimatedHours === 0)) throw new Error(`阶段 ${p.id} 必须给正数 estimatedHours；待定阶段可用 0 表示未估算。`)
     if (kind === 'training' && p.nodes.some((node) => !p.requiredVerified.includes(node))) throw new Error(`训练阶段 ${p.id} 的节点必须全部列入 requiredVerified，不能用空验收绕过检测。`)
+    const preserved = completed[index] && JSON.stringify(corePhase(completed[index])) === JSON.stringify(corePhase(p))
+    if (kind === 'training' && !allowMissingChecks && !preserved &&
+      (p.nodes.some((node) => !p.exitChecks.some((check) => check.node === node)) ||
+       p.competencies.some((competency) => !p.exitChecks.some((check) => check.competency === competency)))) throw new Error(`训练阶段 ${p.id} 的 exitChecks 必须覆盖每个节点和能力；文字验收不能代替可检查条件。`)
     if (kind !== 'training' && p.requiredVerified.length) throw new Error(`诊断/待定阶段 ${p.id} 不以既有 verified 验收，请使用新诊断记录。`)
     return { ...p, kind, finding, estimatedHours, prerequisites,
       basis: text(phase.basis, 'basis（观察或待确认问题）', p.id),
@@ -91,6 +130,8 @@ export function validatePlan(phases, { byId, progress, catalog, current = 0 }) {
       if (!nodeMatch && !competencyMatch) throw new Error(`阶段 ${phase.id} 引用了无关的证据记录「${ref}」。`)
     }
     if (phase.kind !== 'training') continue
+    if (phase.nodes.some((node) => !phase.exitChecks.some((check) => check.node === node)) ||
+      phase.competencies.some((competency) => !phase.exitChecks.some((check) => check.competency === competency))) throw new Error(`阶段 ${phase.id} 尚缺结构化 exitChecks；旧路线请 revise 补齐，不会自动猜测验收次数。`)
     const signal = phase.finding === 'gap' ? 'gap' : 'baseline'
     const uncovered = phase.nodes.filter((node) => !phase.evidenceRefs.some((ref) => {
       const entry = records.get(ref)
@@ -111,12 +152,40 @@ export function validatePlan(phases, { byId, progress, catalog, current = 0 }) {
   }
 }
 
-export function missingFreshEvidence(phase, catalog, entryEvidenceRefs, enteredDate, entryEvidenceEvents = []) {
+const validEvidenceDate = (date, enteredDate, today) => typeof date === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(date) &&
+  Number.isFinite(Date.parse(`${date}T12:00:00Z`)) && new Date(`${date}T12:00:00Z`).toISOString().slice(0, 10) === date &&
+  date >= enteredDate && date <= today
+const freshTiming = (entry, enteredDate, today, enteredAt, currentAt) => validEvidenceDate(entry.date, enteredDate, today) &&
+  (entry.occurredAt === undefined || (validOccurredAt(entry.occurredAt) &&
+    (!enteredAt || Date.parse(entry.occurredAt) >= Date.parse(enteredAt)) &&
+    (!currentAt || Date.parse(entry.occurredAt) <= Date.parse(currentAt))))
+
+export function evaluateExitChecks(phase, catalog, entryEvidenceRefs, enteredDate, entryEvidenceEvents = [], today = '9999-12-31', enteredAt = '', currentAt = '') {
+  const old = new Set(entryEvidenceRefs), oldEvents = new Set(entryEvidenceEvents)
+  return (phase.exitChecks ?? []).map((check) => {
+    const events = new Map()
+    for (const entry of catalog) {
+      if ((check.node ? entry.node !== check.node : entry.competency !== check.competency) || entry.signal !== 'baseline' ||
+        !entry.eventId || old.has(entry.id) || oldEvents.has(entry.eventId) || !freshTiming(entry, enteredDate, today, enteredAt, currentAt)) continue
+      if (check.independent !== undefined && entry.independent !== check.independent) continue
+      if (check.maxMinutes !== undefined && (!Number.isFinite(entry.minutes) || entry.minutes <= 0 || entry.minutes > check.maxMinutes)) continue
+      if (check.metric && (entry.metric !== check.metric || !Number.isFinite(entry.value) || entry.value > check.maxValue)) continue
+      events.set(entry.eventId, entry)
+    }
+    const matchedEvents = events.size, distinctDays = new Set([...events.values()].map((entry) => entry.date)).size
+    const missing = []
+    if (matchedEvents < check.minEvents) missing.push(`合格新事件 ${matchedEvents}/${check.minEvents}`)
+    if (distinctDays < (check.minDistinctDays ?? 1)) missing.push(`不同日期 ${distinctDays}/${check.minDistinctDays ?? 1}`)
+    return { ...check, target: check.node || check.competency, matchedEvents, distinctDays, passed: missing.length === 0, missing }
+  })
+}
+
+export function missingFreshEvidence(phase, catalog, entryEvidenceRefs, enteredDate, entryEvidenceEvents = [], today = '9999-12-31', enteredAt = '', currentAt = '') {
   const old = new Set(entryEvidenceRefs)
   const events = new Set(entryEvidenceEvents)
   const missingNodes = phase.nodes.filter((node) => !catalog.some((entry) => entry.node === node && !old.has(entry.id) &&
-    !events.has(entry.eventId) && entry.date >= enteredDate && (phase.kind === 'diagnostic' || entry.signal === 'baseline')))
+    !events.has(entry.eventId) && freshTiming(entry, enteredDate, today, enteredAt, currentAt) && (phase.kind === 'diagnostic' || entry.signal === 'baseline')))
   const missingCompetencies = phase.competencies.filter((competency) => !catalog.some((entry) => entry.competency === competency && !old.has(entry.id) &&
-    !events.has(entry.eventId) && entry.date >= enteredDate && (phase.kind === 'diagnostic' || entry.signal === 'baseline')))
+    !events.has(entry.eventId) && freshTiming(entry, enteredDate, today, enteredAt, currentAt) && (phase.kind === 'diagnostic' || entry.signal === 'baseline')))
   return [...missingNodes, ...missingCompetencies]
 }

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 ? '本周主线到期，先复盘并修订。' : '',