acmer-coach 2.0.0 → 2.2.0

package/lib/curriculum.js

@@ -1,5 +1,5 @@
 // 课程路线保存教学决定；进度和检测证据仍从 PROGRESS 读取。
-import { readFileSync, writeFileSync, renameSync, unlinkSync } from 'node:fs'
+import { copyFileSync, readFileSync, writeFileSync, renameSync, unlinkSync } from 'node:fs'
 import { join } from 'node:path'
 import { randomUUID } from 'node:crypto'
 import { parse, stringify } from 'yaml'
@@ -17,13 +17,18 @@ function validDate(value) {
   const d = new Date(`${value}T12:00:00Z`)
   return Number.isFinite(d.getTime()) && d.toISOString().slice(0, 10) === value
 }
-export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSchedule = () => ({ days: {} }), now = () => new Date() }) {
+export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSchedule = () => ({ days: {} }), loadStrategyEvidence = () => [], now = () => new Date() }) {
   const path = join(dataDir, 'CURRICULUM.yaml')
-  const evidence = () => collectEvidence(loadProgress(), loadSchedule()).filter((entry) => loadMap().byId.has(entry.node))
+  const evidence = () => [
+    ...collectEvidence(loadProgress(), loadSchedule()).filter((entry) => loadMap().byId.has(entry.node)),
+    ...loadStrategyEvidence().filter((entry) => entry && typeof entry.id === 'string' && typeof entry.competency === 'string'),
+  ]
   function enter(doc, catalog) {
     doc.enteredAt = now().toISOString()
-    doc.entryEvidenceRefs = catalog.filter((entry) => doc.phases[doc.current].nodes.includes(entry.node)).map((entry) => entry.id)
-    doc.entryEvidenceEvents = catalog.filter((entry) => doc.phases[doc.current].nodes.includes(entry.node)).map((entry) => entry.eventId)
+    const phase = doc.phases[doc.current]
+    const inPhase = catalog.filter((entry) => phase.nodes.includes(entry.node) || phase.competencies.includes(entry.competency))
+    doc.entryEvidenceRefs = inPhase.map((entry) => entry.id)
+    doc.entryEvidenceEvents = inPhase.map((entry) => entry.eventId)
   }
   function budget(doc) {
     const remainingEstimatedHours = doc.status === 'complete' ? 0 : doc.phases.slice(doc.current).reduce((sum, phase) => sum + phase.estimatedHours, 0)
@@ -75,7 +80,12 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
     const temporary = `${path}.${randomUUID()}.tmp`
     try {
       writeFileSync(temporary, '# 课程路线；进度与检测证据仍以 PROGRESS.yaml 为准。\n' + stringify(doc, { lineWidth: 0 }), 'utf8')
-      renameSync(temporary, path)
+      try { renameSync(temporary, path) } catch (err) {
+        if (!['EPERM', 'EEXIST'].includes(err.code)) throw err
+        try { unlinkSync(path) } catch (removeErr) { if (removeErr.code !== 'ENOENT') throw err }
+        copyFileSync(temporary, path)
+        unlinkSync(temporary)
+      }
     } finally {
       try { unlinkSync(temporary) } catch (err) { if (err.code !== 'ENOENT') throw err }
     }
@@ -84,7 +94,7 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
     const empty = {
       ok: true, reject: '', exists: false, revision: 0, status: 'none', goal: '', baseline: '',
       weeklyHours: 0, deadline: '', phaseId: '', phaseTitle: '', outcome: '', exitCriteria: '',
-      focusNodes: [], focusUntil: '', focusExpired: false, requiredVerified: [], missingVerified: [],
+      focusNodes: [], phaseCompetencies: [], focusUntil: '', focusExpired: false, requiredVerified: [], missingVerified: [],
       pendingNodes: [], roadmap: [], history: [], updated: '',
       needsReview: false, planningWarnings: [], evidence: [], evidenceCount: 0, evidenceTruncated: false,
       missingPrerequisites: [], missingFreshEvidence: [],
@@ -103,6 +113,7 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
       baseline: doc.baseline, weeklyHours: doc.weeklyHours, deadline: doc.deadline,
       phaseId: phase.id, phaseTitle: phase.title, outcome: phase.outcome, exitCriteria: phase.exitCriteria,
       focusNodes: doc.focusNodes.length ? doc.focusNodes : phase.nodes,
+      phaseCompetencies: phase.competencies,
       focusUntil: doc.focusUntil, focusExpired: Boolean(doc.focusUntil && doc.focusUntil < dateOf(now)),
       requiredVerified: phase.requiredVerified,
       missingVerified: phase.requiredVerified.filter((n) => progress.nodes?.[n]?.status !== 'verified'),
@@ -112,9 +123,9 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
       history: doc.history.map(({ revision, action, reason, at, fromPhase, toPhase }) => ({ revision, action, reason, at, fromPhase, toPhase })),
       updated: doc.updated,
       needsReview: planningWarnings.length > 0, planningWarnings,
-      evidence: catalog.filter((entry) => phase.nodes.includes(entry.node)).slice(-200),
-      evidenceCount: catalog.filter((entry) => phase.nodes.includes(entry.node)).length,
-      evidenceTruncated: catalog.filter((entry) => phase.nodes.includes(entry.node)).length > 200,
+      evidence: catalog.filter((entry) => phase.nodes.includes(entry.node) || phase.competencies.includes(entry.competency)).slice(-200),
+      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],
       ...budget(doc),
@@ -180,7 +191,7 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
               throw new Error('当前诊断不能通过 revise 改成训练或删掉待诊断节点；先产生新记录，再 advance。')
             }
             doc.phases = phases
-            const workKeys = ['kind', 'nodes', 'outcome', 'exitCriteria', 'basis', 'finding', 'evidenceRefs']
+            const workKeys = ['kind', 'nodes', 'competencies', 'outcome', 'exitCriteria', '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)
           }
         }
@@ -237,7 +248,8 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
       return [
         `- 长期目标：${state.goal}；课程版本 ${state.revision}（${state.status}）`,
         `- 当前阶段：${state.phaseTitle}（${state.phaseId}）；能力成果：${state.outcome}`,
-        `- 主线节点：${state.focusNodes.join('、')}`,
+        `- 主线节点：${state.focusNodes.join('、') || '由比赛能力证据驱动'}`,
+        state.phaseCompetencies.length ? `- 阶段比赛能力：${state.phaseCompetencies.join('、')}` : '',
         `- 阶段验收：${state.exitCriteria}`,
         `- 阶段编排依据：${state.roadmap.find((phase) => phase.active)?.basis ?? ''}`,
         ...state.planningWarnings.map((warning) => `- 编排待核查：${warning}`),
@@ -255,7 +267,7 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
 const stringList = { type: 'array', items: { type: 'string' } }
 const phaseProperties = {
   id: { type: 'string', required: true }, title: { type: 'string', required: true },
-  outcome: { type: 'string', required: true }, nodes: { ...stringList, required: true },
+  outcome: { type: 'string', required: true }, nodes: stringList, competencies: stringList,
   exitCriteria: { type: 'string', required: true }, requiredVerified: stringList,
   kind: { type: 'string', required: true, enum: ['diagnostic', 'training', 'provisional', 'legacy'], description: '诊断/有证据训练/远期待定；legacy只用于保留已完成历史。' },
   finding: { type: 'string', required: true, enum: ['gap', 'extension', 'unknown'] },
@@ -271,14 +283,14 @@ export function curriculumTool(store) {
   const required = (type) => ({ type, required: true })
   return {
     name: 'coach_curriculum',
-    description: '按真实记录编排长期课程：assess取检测/判因/训练的证据id；read查看路线；create建立；revise按证据调整；advance验收后推进。训练阶段必须逐节点有真实短板或进阶起点，并按显式前置与必验阶段排序；无依据先diagnostic，远期可provisional但不能直接执行。阶段需目标贡献、优先级理由、时间估算。写操作带expectedRevision和reason；诊断/训练验收都需进入阶段后的新事件，不能复用旧记录。',
+    description: '按真实记录编排长期课程：assess取检测/判因/训练/VP的证据id；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条，截断时缩小节点范围。' },
       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，可留空。' },
-      phases: { type: 'array', description: '按证据与前置排序；training所有节点必验；diagnostic收集新记录；provisional保留远期假设。', items: { type: 'object', additionalProperties: false, properties: phaseProperties } },
+      phases: { type: 'array', description: '按证据与前置排序；阶段至少绑定一个地图节点或比赛能力；training地图节点必验、能力阶段用新 VP/复盘证据验收；diagnostic收集新记录；provisional保留远期假设。', items: { type: 'object', additionalProperties: false, properties: phaseProperties } },
       focusNodes: { ...stringList, description: '当前阶段内的本周主线，空数组表示沿用阶段节点。' },
       focusUntil: { type: 'string', description: '本周主线截止日期 YYYY-MM-DD，可留空；到期先复盘。' },
       reason: { type: 'string', description: '建立/调整的依据；advance 时写验收证据及记录来源，至少 10 字。' },
@@ -289,16 +301,16 @@ export function curriculumTool(store) {
         status: required('string'), goal: required('string'), baseline: required('string'), weeklyHours: required('number'),
         deadline: required('string'), phaseId: required('string'), phaseTitle: required('string'), outcome: required('string'),
         exitCriteria: required('string'), focusUntil: required('string'), focusExpired: required('boolean'), updated: required('string'),
-        focusNodes: { ...stringList, required: true }, requiredVerified: { ...stringList, required: true },
+          focusNodes: { ...stringList, required: true }, phaseCompetencies: { ...stringList, required: true }, requiredVerified: { ...stringList, required: true },
         missingVerified: { ...stringList, required: true }, pendingNodes: { ...stringList, required: true },
         needsReview: required('boolean'), planningWarnings: { ...stringList, required: true },
         missingPrerequisites: { ...stringList, required: true }, missingFreshEvidence: { ...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')])) } },
+          { ...Object.fromEntries(['id', 'eventId', 'source', 'node', 'date', 'signal', 'summary', 'fingerprint'].map((key) => [key, required('string')])), competency: { type: 'string' } } } },
         roadmap: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: {
-          ...phaseProperties, requiredVerified: { ...stringList, required: true }, position: required('integer'), active: required('boolean'),
+          ...phaseProperties, nodes: { ...stringList, required: true }, competencies: { ...stringList, required: true }, requiredVerified: { ...stringList, required: true }, position: required('integer'), active: required('boolean'),
           prerequisites: { ...stringList, required: true },
         } } },
         history: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: {
@@ -308,14 +320,14 @@ 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.signal} · ${entry.summary}`),
+          ...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.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.exitCriteria}`,
+            `当前主线：${state.focusNodes.join('、') || '能力证据驱动'}`, state.phaseCompetencies.length ? `阶段比赛能力：${state.phaseCompetencies.join('、')}` : '', `验收：${state.exitCriteria}`,
             state.missingVerified.length ? `必验缺口：${state.missingVerified.join('、')}` : '必验节点已有记录；仍需判断能力成果是否达到，不能自动推进。',
             state.pendingNodes.length ? `先完成当前单元：${state.pendingNodes.join('、')}` : '',
             state.focusExpired ? '本周主线到期，先复盘并修订。' : '',

package/lib/strategy.js

@@ -1,7 +1,7 @@
 // Goal-driven strategy layer for acmer-coach.
 // It stores contest targets, VP evidence and postmortems separately from
 // PROGRESS.yaml so the existing knowledge workflow keeps its meaning.
-import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
+import { copyFileSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
 import { parse, stringify } from 'yaml'
 
@@ -29,8 +29,22 @@ function readYaml(path, fallback) {
 
 function writeYaml(path, header, value) {
   const tmp = `${path}.${process.pid}.${Date.now()}.tmp`
-  writeFileSync(tmp, header + stringify(value, { lineWidth: 0 }), 'utf8')
-  renameSync(tmp, path)
+  let moved = false
+  try {
+    writeFileSync(tmp, header + stringify(value, { lineWidth: 0 }), 'utf8')
+    try { renameSync(tmp, path) } catch (err) {
+      if (!['EPERM', 'EEXIST'].includes(err.code)) throw err
+      // Windows sandbox may refuse rename over an existing file; keep the complete tmp file and replace by copy.
+      try { unlinkSync(path) } catch (removeErr) { if (removeErr.code !== 'ENOENT') throw err }
+      copyFileSync(tmp, path)
+      unlinkSync(tmp)
+    }
+    moved = true
+  } finally {
+    if (!moved) {
+      try { unlinkSync(tmp) } catch { /* best effort cleanup */ }
+    }
+  }
 }
 
 function normalizePriority(value) {
@@ -94,14 +108,46 @@ function normalizePostmortem(value) {
 export function createStrategyStore({ dataDir, competenciesPath, now = () => new Date() }) {
   const targetPath = join(dataDir, 'TARGET.yaml')
   const vpPath = join(dataDir, 'VP_EVENTS.yaml')
-  const loadTarget = () => ({ ...emptyTarget(), ...readYaml(targetPath, emptyTarget) })
-  const loadVp = () => ({ ...emptyVp(), ...readYaml(vpPath, emptyVp) })
+  const validateTarget = (doc) => {
+    const errors = []
+    if (doc.version !== 1) errors.push('version 必须是 1')
+    if (!Number.isInteger(doc.revision) || doc.revision < 0) errors.push('revision 必须是非负整数')
+    if (!Array.isArray(doc.priorities)) errors.push('priorities 必须是数组')
+    else if (doc.priorities.some((item) => !normalizePriority(item))) errors.push('priorities 含有无效的 id/weight')
+    if (!doc.constraints || typeof doc.constraints !== 'object' || Array.isArray(doc.constraints)) errors.push('constraints 必须是对象')
+    return errors
+  }
+  const validateVp = (doc) => {
+    const errors = []
+    if (doc.version !== 1) errors.push('version 必须是 1')
+    if (!Number.isInteger(doc.revision) || doc.revision < 0) errors.push('revision 必须是非负整数')
+    if (!Array.isArray(doc.events)) errors.push('events 必须是数组')
+    else if (doc.events.some((item) => !normalizeEvent(item))) errors.push('events 含有无效记录')
+    if (!Array.isArray(doc.postmortems)) errors.push('postmortems 必须是数组')
+    else if (doc.postmortems.some((item) => !normalizePostmortem(item))) errors.push('postmortems 含有无效记录')
+    return errors
+  }
+  const loadTarget = () => {
+    const doc = { ...emptyTarget(), ...readYaml(targetPath, emptyTarget) }
+    const errors = validateTarget(doc)
+    if (errors.length) throw new Error(`TARGET.yaml 数据无效：${errors.join('；')}`)
+    return doc
+  }
+  const loadVp = () => {
+    const doc = { ...emptyVp(), ...readYaml(vpPath, emptyVp) }
+    const errors = validateVp(doc)
+    if (errors.length) throw new Error(`VP_EVENTS.yaml 数据无效：${errors.join('；')}`)
+    return doc
+  }
   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 ?? []
 
   function target(action = 'read', args = {}) {
-    const old = loadTarget()
+    let old
+    try { old = loadTarget() } catch (err) {
+      return { ok: false, reject: err.message, ...emptyTarget() }
+    }
     if (action === 'read') return { ok: true, reject: '', ...old }
     if (!['set', 'clear'].includes(action)) return { ok: false, reject: 'action 只能是 read/set/clear。', ...old }
     if (args.expectedRevision !== old.revision) return { ok: false, reject: '目标版本已变化；先 read，再按当前 revision 更新。', ...old }
@@ -114,7 +160,9 @@ export function createStrategyStore({ dataDir, competenciesPath, now = () => new
     if (!clean(args.contest) || !isoDay(date) || !clean(args.result)) return { ok: false, reject: 'set 必须提供 contest、真实 YYYY-MM-DD 的 date 和 result。', ...old }
     const weeklyHours = Number(args.weeklyHours)
     if (!Number.isFinite(weeklyHours) || weeklyHours <= 0 || weeklyHours > 168) return { ok: false, reject: 'weeklyHours 必须在 0 和 168 之间。', ...old }
-    const priorities = asArray(args.priorities).map(normalizePriority).filter(Boolean)
+    const rawPriorities = asArray(args.priorities)
+    const priorities = rawPriorities.map(normalizePriority).filter(Boolean)
+    if (rawPriorities.length !== priorities.length) return { ok: false, reject: 'priorities 中有无效项；每项都要提供正数 weight 和非空 id。', ...old }
     if (!priorities.length) return { ok: false, reject: '至少给一个能力优先级：id + weight。', ...old }
     const known = new Set(loadCompetencies().map((item) => item.id))
     const unknown = priorities.map((item) => item.id).filter((id) => !known.has(id))
@@ -132,13 +180,19 @@ export function createStrategyStore({ dataDir, competenciesPath, now = () => new
   }
 
   function vpImport(events = []) {
-    const old = loadVp()
-    const normalized = events.map(normalizeEvent).filter(Boolean)
+    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]))
     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)
-    return { ok: true, reject: '', imported: normalized.length, total: next.events.length, revision: next.revision, events: next.events }
+    return { ok: true, reject: '', imported: normalized.length, total: next.events.length, revision: next.revision, events: next.events, invalid: [] }
   }
 
   function postmortem(value) {
@@ -155,8 +209,16 @@ export function createStrategyStore({ dataDir, competenciesPath, now = () => new
   }
 
   function focus() {
-    const targetDoc = loadTarget()
-    const vp = loadVp()
+    let targetDoc, vp
+    try {
+      targetDoc = loadTarget()
+      vp = loadVp()
+    } catch (err) {
+      return {
+        ok: false, reject: err.message, contest: '', deadline: '', focus: [], postponed: [],
+        evidenceEvents: 0, postmortems: 0,
+      }
+    }
     const catalog = loadCompetencies()
     if (!targetDoc.contest) return {
       ok: false, reject: '还没有比赛目标，先用 coach_target set。', contest: '', deadline: '',
@@ -164,9 +226,15 @@ export function createStrategyStore({ dataDir, competenciesPath, now = () => new
     }
     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)
+      }
+    }
     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
+      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 证据。') }
@@ -181,6 +249,47 @@ export function createStrategyStore({ dataDir, competenciesPath, now = () => new
     return { ok: false, reject: `「${nodeOrId}」还没有范围卡片，不能凭空编造适用范围；先补充 COMPETENCIES.yaml。`, found: false, id: nodeOrId, title: nodeOrId, contestUse: '', nodes: [], appliesTo: [], extensions: [], notFor: [], commonFailures: [], transferProblems: [], exitEvidence: [] }
   }
 
+  function route(nodeOrId, { purpose = 'progress', courseBound = false } = {}) {
+    const node = clean(nodeOrId)
+    let targetDoc
+    try { targetDoc = loadTarget() } catch (err) { return { ok: false, reject: err.message, node, purpose, courseBound: Boolean(courseBound), targetAligned: false, competencyIds: [] } }
+    const base = { node, purpose, courseBound: Boolean(courseBound), targetAligned: true, competencyIds: [] }
+    if (!targetDoc.contest || purpose !== 'progress' || courseBound) return { ok: true, reject: '', ...base }
+    const catalog = loadCompetencies()
+    const priorityIds = new Set(targetDoc.priorities.map((item) => item.id))
+    const current = focus()
+    const currentIds = new Set((current.focus ?? []).map((item) => item.id))
+    const targetCards = catalog.filter((item) => priorityIds.has(item.id) && item.nodes?.includes(node))
+    const currentCards = targetCards.filter((item) => currentIds.has(item.id))
+    const mappedTarget = catalog.filter((item) => priorityIds.has(item.id) && item.nodes?.length)
+    if (mappedTarget.length && !currentCards.length) {
+      return { ok: false, reject: `「${node}」不服务当前比赛重点；当前重点是 ${current.focus.map((item) => item.id).join('、')}。如果这是课程主线，请带 curriculumRevision；如果是补漏/复习，请声明 purpose 和 routeReason。`, ...base, targetAligned: false, competencyIds: targetCards.map((item) => item.id) }
+    }
+    return { ok: true, reject: '', ...base, targetAligned: currentCards.length > 0, competencyIds: currentCards.map((item) => item.id) }
+  }
+
+  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 })
+        }
+      }
+      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 })
+      }
+      return { ok: true, reject: '', evidence: result }
+    } catch (err) { return { ok: false, reject: err.message, evidence: [] } }
+  }
+
   function context() {
     const t = loadTarget()
     if (!t.contest) return '- 比赛目标：尚未建立；先用 coach_target set，不要把 rating 当成长期目标。'
@@ -194,7 +303,7 @@ export function createStrategyStore({ dataDir, competenciesPath, now = () => new
     ].filter(Boolean).join('\n')
   }
 
-  return { target, vpImport, postmortem, focus, scope, context, loadTarget, loadVp, loadCompetencies }
+  return { target, vpImport, postmortem, focus, scope, route, evidence, context, loadTarget, loadVp, loadCompetencies }
 }
 
 export const normalizeVpEvent = normalizeEvent

package/lib/vp-client.js

@@ -0,0 +1,148 @@
+import { chmodSync, copyFileSync, mkdirSync, readFileSync, renameSync, rmSync, unlinkSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+const DEFAULT_BASE_URL = 'https://xiaojing.run'
+
+const cleanBaseUrl = (value) => {
+  const url = new URL(String(value || DEFAULT_BASE_URL))
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.search || url.hash) {
+    throw new Error('VP baseUrl 必须是干净的 http/https 地址')
+  }
+  return url.toString().replace(/\/$/, '')
+}
+
+function safeAccount(value) {
+  if (!value || typeof value !== 'object' || !Number.isInteger(Number(value.id))) throw new Error('VP 返回了无效账号')
+  return { id: Number(value.id), handle: String(value.handle || ''), display_name: String(value.display_name || value.handle || '') }
+}
+
+function atomicJson(path, value, mode = 0o600) {
+  const tmp = `${path}.${process.pid}.${Date.now()}.tmp`
+  writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, 'utf8')
+  try { chmodSync(tmp, mode) } catch { /* Windows 没有 Unix mode，不影响原子写 */ }
+  try { renameSync(tmp, path) } catch (err) {
+    if (err.code !== 'EPERM' && err.code !== 'EEXIST') throw err
+    try { unlinkSync(path) } catch (removeErr) { if (removeErr.code !== 'ENOENT') throw err }
+    copyFileSync(tmp, path)
+    unlinkSync(tmp)
+  }
+}
+
+export function createVpClient({ dataDir, fetchImpl = globalThis.fetch, now = () => new Date() } = {}) {
+  if (typeof fetchImpl !== 'function') throw new Error('VP 客户端需要 fetch')
+  const root = join(dataDir, 'vp-accounts')
+  const registryPath = join(dataDir, 'VP_ACCOUNTS.json')
+
+  const loadRegistry = () => {
+    try {
+      const doc = JSON.parse(readFileSync(registryPath, 'utf8'))
+      return doc && typeof doc === 'object' ? doc : { activeAccountId: '', accounts: {} }
+    } catch (err) {
+      if (err.code === 'ENOENT') return { version: 1, activeAccountId: '', accounts: {} }
+      throw err
+    }
+  }
+  const saveRegistry = (value) => atomicJson(registryPath, { version: 1, ...value })
+  const accountDir = (id) => join(root, String(id))
+  const tokenPath = (id) => join(accountDir(id), 'TOKEN.json')
+  const loadToken = (id) => JSON.parse(readFileSync(tokenPath(id), 'utf8')).access_token
+  const active = () => {
+    const registry = loadRegistry()
+    const id = Number(registry.activeAccountId || 0)
+    if (!id) return null
+    const meta = registry.accounts?.[String(id)]
+    if (!meta) return null
+    return { id, account: safeAccount(meta.account), baseUrl: cleanBaseUrl(meta.baseUrl || DEFAULT_BASE_URL) }
+  }
+  const request = async (baseUrl, path, { token, method = 'GET', body } = {}) => {
+    const response = await fetchImpl(`${cleanBaseUrl(baseUrl)}${path}`, {
+      method, headers: { accept: 'application/json', ...(body ? { 'content-type': 'application/json' } : {}), ...(token ? { authorization: `Bearer ${token}` } : {}) },
+      body: body ? JSON.stringify(body) : undefined,
+    })
+    let payload
+    try { payload = await response.json() } catch { payload = { detail: await response.text() } }
+    if (!response.ok) throw new Error(`VP ${response.status}: ${payload?.detail || payload?.message || '请求失败'}`)
+    return payload
+  }
+  const requireActive = () => {
+    const current = active()
+    if (!current) throw new Error('还没有连接 VP；先调用 coach_vp_connect start/finish')
+    return { ...current, token: loadToken(current.id) }
+  }
+  const verifyAccount = (current, value) => {
+    const returned = safeAccount(value)
+    if (returned.id !== current.id) throw new Error(`VP account mismatch: 当前是 ${current.id}，接口返回 ${returned.id}`)
+    return returned
+  }
+
+  return {
+    async start({ baseUrl = DEFAULT_BASE_URL } = {}) {
+      const clean = cleanBaseUrl(baseUrl)
+      const result = await request(clean, '/api/coach/auth/start', { method: 'POST', body: {
+        redirect_uri: 'http://127.0.0.1:8765/coach/callback',
+        scopes: ['profile', 'contests', 'submissions', 'replay'],
+      } })
+      return { ok: true, requestId: result.request_id, authorizeUrl: result.authorize_url, expiresAt: result.expires_at, baseUrl: clean }
+    },
+    async finish({ code, baseUrl = DEFAULT_BASE_URL } = {}) {
+      const clean = cleanBaseUrl(baseUrl)
+      const result = await request(clean, '/api/coach/auth/exchange', { method: 'POST', body: { code: String(code || '') } })
+      const account = safeAccount(result.user)
+      const dir = accountDir(account.id)
+      mkdirSync(dir, { recursive: true })
+      atomicJson(tokenPath(account.id), { access_token: String(result.access_token), saved_at: now().toISOString() })
+      const registry = loadRegistry()
+      registry.accounts = registry.accounts || {}
+      registry.accounts[String(account.id)] = { account, baseUrl: clean, lastSyncAt: registry.accounts[String(account.id)]?.lastSyncAt || '' }
+      registry.activeAccountId = account.id
+      saveRegistry(registry)
+      return { ok: true, account, activeAccountId: account.id }
+    },
+    async status() {
+      const current = active()
+      if (!current) return { connected: false, account: null, activeAccountId: null }
+      try {
+        const remote = await request(current.baseUrl, '/api/coach/me', { token: loadToken(current.id) })
+        const account = verifyAccount(current, remote.user)
+        return { connected: true, account, activeAccountId: current.id, baseUrl: current.baseUrl, readOnly: remote.read_only !== false }
+      } catch (err) {
+        return { connected: false, account: current.account, activeAccountId: current.id, error: err.message }
+      }
+    },
+    async sync({ limit = 200, includeProfile = true } = {}) {
+      const current = requireActive()
+      const registry = loadRegistry()
+      const accountMeta = registry.accounts[String(current.id)] || {}
+      const cursor = accountMeta.cursor || { submission_id: 0, event_id: 0 }
+      const query = new URLSearchParams({ submission_cursor: String(cursor.submission_id || 0), event_cursor: String(cursor.event_id || 0), limit: String(Math.max(1, Math.min(500, Number(limit) || 200))), include_profile: includeProfile ? '1' : '0' })
+      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() })
+      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') }
+    },
+    async replay({ contestId, limit = 50000 } = {}) {
+      const current = requireActive()
+      const payload = await request(current.baseUrl, `/api/coach/replay/${encodeURIComponent(String(contestId))}?limit=${Math.max(1, Math.min(50000, Number(limit) || 50000))}`, { token: current.token })
+      const account = verifyAccount(current, payload.account)
+      const result = { ...payload, account, cachedPath: join(accountDir(current.id), `REPLAY-${String(contestId)}.json`) }
+      atomicJson(result.cachedPath, { ...payload, account, cached_at: now().toISOString() })
+      return result
+    },
+    disconnect() {
+      const current = active()
+      if (!current) return { ok: true, disconnected: false }
+      try { rmSync(tokenPath(current.id), { force: true }) } catch { /* best effort */ }
+      const registry = loadRegistry()
+      registry.activeAccountId = ''
+      saveRegistry(registry)
+      return { ok: true, disconnected: true, account: current.account, cached: true }
+    },
+    localStatus() {
+      const current = active()
+      return current ? { connected: true, account: current.account, activeAccountId: current.id, baseUrl: current.baseUrl } : { connected: false, account: null, activeAccountId: null }
+    },
+  }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "acmer-coach",
   "description": "小鲸教练插件：把「位置 + 判断」从小鲸的转述里拿回来。读 MAP/DEPENDS/PROGRESS，给唯一动作、判因、检测。热插拔，删掉即还原。",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Miantiao1231/acmer-coach.git"

package/verify-shape.mjs

@@ -169,7 +169,15 @@ const cases = [
   ['coach_ping', {}],
   ['coach_target', { action: 'read' }],
   ['coach_target', { action: 'set', expectedRevision: 0, contest: '测试区域赛', date: '2026-10-18', result: '金牌', teamMode: 'team', weeklyHours: 20, priorities: [{ id: 'contest-reading', weight: 80, reason: '测试目标' }] }],
+  // 真正走一遍「目标 → 动作」硬闸：不属于当前能力的 progress 节点必须拒绝，
+  // 再切回无地图能力的读题卡，保留后续旧夹具的成功路径。
+  ['coach_target', { action: 'set', expectedRevision: 1, contest: '测试区域赛', date: '2026-10-18', result: '金牌', teamMode: 'team', weeklyHours: 20, priorities: [{ id: 'dp-modeling', weight: 80, reason: '测试硬闸' }] }],
+  ['coach_assign#target-gate', { node: 'B', deliverable: '把代码贴给我', why: '测试目标硬闸', minutes: 60, teachMinutes: 25 }],
+  ['coach_target', { action: 'set', expectedRevision: 2, contest: '测试区域赛', date: '2026-10-18', result: '金牌', teamMode: 'team', weeklyHours: 20, priorities: [{ id: 'contest-reading', weight: 80, reason: '测试目标' }] }],
   ['coach_vp_import', { events: [{ eventId: 'shape-vp', contest: '测试 VP', date: today, durationMinutes: 300, problems: [{ problemId: 'A', status: 'AC', competencies: ['contest-reading'] }] }] }],
+  ['coach_vp_connect', { action: 'status' }],
+  ['coach_vp_sync', {}],
+  ['coach_vp_replay', { contestId: 1 }],
   ['coach_postmortem', { eventId: 'shape-vp', competencies: ['contest-reading'], rootCauses: ['测试复盘'], nextActions: ['测试动作'] }],
   ['coach_focus', {}],
   ['coach_scope', { id: 'contest-reading' }],
@@ -298,6 +306,11 @@ for (const [name, args, preset] of cases) {
     bad++
     continue
   }
+  if (name === 'coach_assign#target-gate' && out.accepted !== false) {
+    console.log(`  FAIL ${name}  → 目标硬闸没有拒绝无关 progress 节点`)
+    bad++
+    continue
+  }
   const errs = []
   validate(tool.output.schema, out, 'out', errs)
   let renderNote = ''