acmer-coach 2.0.0 → 2.2.0

package/index.js

@@ -23,7 +23,7 @@
 //   · `file:` 依赖装出来的是**硬链接**，不是拷贝。原地写两边同变，但改名式
 //     写入（Edit 工具、VS Code 原子保存）会**断开链接**，断了两边分家，
 //     而 `dsh plugin add` 认不出分家、不重链也不报错 —— 所以改完一律跑 dev.sh。
-import { readFileSync, writeFileSync, renameSync, statSync } from 'node:fs'
+import { copyFileSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, renameSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 import { parse, stringify } from 'yaml'
@@ -31,11 +31,12 @@ import { defineTool } from '@deepseek-ai/dsh-tools'
 import { initDataDir, syncCodeforces, contactEvidence, importPool, importRecords } from './lib/setup.js'
 import { createCurriculumStore, curriculumTool } from './lib/curriculum.js'
 import { createStrategyStore } from './lib/strategy.js'
+import { createVpClient } from './lib/vp-client.js'
 
 const name = 'acmer-coach'
 const inject = ['tools']
 
-const VERSION = '2.0.0'
+const VERSION = '2.2.0'
 
 // 块结构（方针 §4.1.1）：40 自己做 + 10 解决遗留 + 10 重写 = 60 分钟。
 // 这是**一个题目循环**的固定形状。时间不够该换更小的题，不是把块压扁。
@@ -71,11 +72,30 @@ const TEACH_FLOOR_MIN = 10
 const DATA_DIR_EXPLICIT = Boolean(process.env.COACH_DATA_DIR)
 const DATA_DIR = process.env.COACH_DATA_DIR || join(homedir(), '.dsh', 'knowledge')
 const MAP_PATH = () => join(DATA_DIR, 'MAP.yaml')
-const curriculum = createCurriculumStore({ dataDir: DATA_DIR, loadMap, loadProgress, loadSchedule })
-const strategy = createStrategyStore({
-  dataDir: DATA_DIR,
-  competenciesPath: join(import.meta.dirname, 'assets', 'knowledge', 'COMPETENCIES.yaml'),
-})
+let ACTIVE_DATA_DIR = DATA_DIR
+let strategy
+let curriculum
+function createStores(dataDir) {
+  strategy = createStrategyStore({
+    dataDir, competenciesPath: join(import.meta.dirname, 'assets', 'knowledge', 'COMPETENCIES.yaml'),
+  })
+  curriculum = createCurriculumStore({
+    dataDir, loadMap, loadProgress, loadSchedule,
+    loadStrategyEvidence: () => strategy.evidence().evidence,
+  })
+}
+createStores(ACTIVE_DATA_DIR)
+
+function switchCoachWorkspace(accountId = '') {
+  ACTIVE_DATA_DIR = accountId ? join(DATA_DIR, 'vp-accounts', String(accountId)) : DATA_DIR
+  mkdirSync(ACTIVE_DATA_DIR, { recursive: true })
+  createStores(ACTIVE_DATA_DIR)
+  return ACTIVE_DATA_DIR
+}
+
+const vpClient = createVpClient({ dataDir: DATA_DIR })
+const savedVp = vpClient.localStatus()
+if (savedVp.connected) switchCoachWorkspace(savedVp.activeAccountId)
 
 // 探针要的文件，各自代表一条后面的依赖：
 //   MAP.yaml      地图（coach_next 读它算候选）
@@ -167,7 +187,7 @@ function loadMap() {
 //
 // 游标显式存，不靠"已验证的最大深度"推 —— 推出来的东西没法手改，
 // 而且他想复习某节时游标要能停在那儿。
-const PROGRESS_PATH = () => join(DATA_DIR, 'PROGRESS.yaml')
+const PROGRESS_PATH = () => join(ACTIVE_DATA_DIR, 'PROGRESS.yaml')
 
 function emptyProgress() {
   return { version: 1, cursor: '', updated: '', nodes: {}, pending: null }
@@ -256,6 +276,16 @@ const PROGRESS_HEADER = `
 // 原子写：先写 .tmp 再 rename。半路崩了也不会把真相源撕成半个文件。
 // ⚠️ 千万不要在解析失败时静默返回空进度再写回 —— 那是**拿空数据覆盖真相源**。
 //    loadProgress 遇到非 ENOENT 的错一律抛，就是要让这种情况炸出来。
+function replaceFile(tmp, destination) {
+  try { renameSync(tmp, destination) } catch (err) {
+    if (!['EPERM', 'EEXIST'].includes(err.code)) throw err
+    // Windows sandbox may refuse rename over an existing file; replace from the complete temp copy.
+    try { unlinkSync(destination) } catch (removeErr) { if (removeErr.code !== 'ENOENT') throw err }
+    copyFileSync(tmp, destination)
+    unlinkSync(tmp)
+  }
+}
+
 function saveProgress(p) {
   p.updated = localStamp(new Date()).slice(0, 10)
   // 显式列出要落盘的字段，而不是 `stringify(p)` 一把梭 ——
@@ -276,7 +306,7 @@ function saveProgress(p) {
   }
   const tmp = `${PROGRESS_PATH()}.tmp`
   writeFileSync(tmp, PROGRESS_HEADER + stringify(out, { lineWidth: 0 }), 'utf8')
-  renameSync(tmp, PROGRESS_PATH())
+  replaceFile(tmp, PROGRESS_PATH())
   return p
 }
 
@@ -296,7 +326,7 @@ function saveProgress(p) {
 //
 // `actual` 是**校准真实做题速度**的唯一来源 —— 计划 60 分钟实际 95 分钟，
 // 攒几周才知道他的速度到底是多少。这条现在一条数据都没有，所以排程只能保守。
-const SCHEDULE_PATH = () => join(DATA_DIR, 'SCHEDULE.yaml')
+const SCHEDULE_PATH = () => join(ACTIVE_DATA_DIR, 'SCHEDULE.yaml')
 
 function emptySchedule() {
   return { version: 1, updated: '', days: {} }
@@ -370,7 +400,7 @@ function saveSchedule(s) {
   // days 的 key 本身就是日期，也裸着 —— PyYAML 会读成 Date，按字符串索引就 KeyError
   body = body.replace(/^(\s*)(\d{4}-\d{2}-\d{2}):(\s*)$/gm, '$1"$2":')
   writeFileSync(tmp, SCHEDULE_HEADER + body, 'utf8')
-  renameSync(tmp, SCHEDULE_PATH())
+  replaceFile(tmp, SCHEDULE_PATH())
   return s
 }
 
@@ -1397,6 +1427,7 @@ const reachableOf = (entry, rating) =>
   !entry || !rating || Number(entry) <= rating + REACH_BUFFER
 
 const SKILLTREE_HTML = () => join(DATA_DIR, 'skilltree.html')
+const VP_HTML = () => join(import.meta.dirname, 'assets', 'knowledge', 'vp.html')
 
 // ── /coach 路由：把技能树挂在 dsh 自己的 web 服务上 ──────────────────
 //
@@ -1479,6 +1510,38 @@ function registerPages(ctx) {
       return
     }
 
+    if (pathname === '/coach/vp.html') {
+      try { return send(res, 200, 'text/html; charset=utf-8', readFileSync(VP_HTML())) }
+      catch (err) { return send(res, 404, 'text/plain; charset=utf-8', `VP 页面缺失（${err?.code ?? err?.message}）`) }
+    }
+
+    if (pathname === '/coach/api/vp/status' && req.method === 'GET') {
+      return sendJson(res, 200, { ok: true, ...vpClient.localStatus() })
+    }
+
+    if (pathname === '/coach/api/vp/replay' && req.method === 'GET') {
+      const id = new URL(req.url ?? '/', 'http://dsh.internal').searchParams.get('contestId')
+      if (!id) return sendJson(res, 400, { ok: false, reject: '缺少 contestId' })
+      try { return sendJson(res, 200, { ok: true, ...(await vpClient.replay({ contestId: id })) }) }
+      catch (err) { return sendJson(res, 400, { ok: false, reject: String(err?.message || err) }) }
+    }
+
+    if (pathname === '/coach/api/vp/connect' && req.method === 'POST') {
+      let body = ''
+      for await (const chunk of req) { body += chunk; if (body.length > 100_000) { req.destroy(); return } }
+      let payload
+      try { payload = JSON.parse(body || '{}') } catch { return sendJson(res, 400, { ok: false, reject: '请求体不是 JSON' }) }
+      try {
+        let result
+        if (payload.op === 'start') result = await vpClient.start({ baseUrl: payload.baseUrl })
+        else if (payload.op === 'finish') { result = await vpClient.finish({ code: payload.code, baseUrl: payload.baseUrl }); switchCoachWorkspace(result.activeAccountId) }
+        else if (payload.op === 'disconnect') { result = vpClient.disconnect(); switchCoachWorkspace('') }
+        else if (payload.op === 'sync') result = await vpClient.sync({})
+        else return sendJson(res, 400, { ok: false, reject: 'op 只能是 start/finish/disconnect/sync' })
+        return sendJson(res, 200, { ok: true, ...result })
+      } catch (err) { return sendJson(res, 400, { ok: false, reject: String(err?.message || err) }) }
+    }
+
     if (pathname === '/coach/skilltree.html') {
       let html
       try {
@@ -1795,6 +1858,44 @@ function wikiPage(src) {
   return { ok: true, text: text.slice(0, 12000), truncated: text.length > 12000, chars: text.length }
 }
 
+const emptyVpAccount = () => ({ id: 0, handle: '', display_name: '' })
+const vpAccount = (value) => value && Number(value.id) > 0
+  ? { id: Number(value.id), handle: String(value.handle || ''), display_name: String(value.display_name || value.handle || '') }
+  : emptyVpAccount()
+
+function vpEventsFromSync(payload, account) {
+  const submissions = Array.isArray(payload?.submissions) ? payload.submissions : []
+  const contests = Array.isArray(payload?.contests) ? payload.contests : []
+  const byContest = new Map()
+  for (const contest of contests) byContest.set(Number(contest.id), contest)
+  const groups = new Map()
+  for (const submission of submissions) {
+    const contestId = Number(submission.contest_id)
+    const problemId = String(submission.problem_id ?? '').trim()
+    if (!contestId || !problemId) continue
+    if (!groups.has(contestId)) groups.set(contestId, new Map())
+    const problems = groups.get(contestId)
+    if (!problems.has(problemId)) problems.set(problemId, [])
+    problems.get(problemId).push(submission)
+  }
+  return [...groups.entries()].map(([contestId, problems]) => {
+    const contest = byContest.get(contestId) || {}
+    const start = String(contest.start_time || [...problems.values()][0]?.[0]?.submitted_at || '')
+    const normalized = [...problems.entries()].map(([problemId, attempts]) => {
+      const solved = attempts.find((item) => ['AC', 'OK', 'ACCEPTED', 'SOLVED'].includes(String(item.verdict || '').toUpperCase()))
+      const at = solved?.submitted_at || attempts.at(-1)?.submitted_at
+      const minutes = start && at ? Math.max(0, Math.round((Date.parse(at) - Date.parse(start)) / 60000)) : 0
+      return { problemId, status: solved ? 'AC' : String(attempts.at(-1)?.verdict || 'UNKNOWN').toUpperCase(), attempts: attempts.length, solveMinutes: minutes, competencies: [] }
+    })
+    return {
+      eventId: `vp:${account.id}:${contestId}`,
+      contest: String(contest.title || contestId), contestId: String(contestId), date: start.slice(0, 10),
+      durationMinutes: Number(contest.duration_min || 0), virtual: true, teamMode: 'team', problems: normalized,
+      note: '由 VP 只读同步生成；具体能力标签在复盘时补充。',
+    }
+  }).filter((event) => /^\d{4}-\d{2}-\d{2}$/.test(event.date) && event.problems.length)
+}
+
 function apply(ctx) {
   // ── 规则层：进 system prompt ──────────────────────────────────────
   //
@@ -1825,6 +1926,93 @@ function apply(ctx) {
   // 课程图回答“有哪些知识点”，策略层回答“为什么现在学这个”。两者分开，
   // 避免把 rating 或游标误当成区域赛目标。
   const strategyText = (v) => [{ type: 'text', text: v.ok ? v.text : `❌ ${v.reject}` }]
+  ctx.tools.register(defineTool({
+    name: 'coach_vp_connect',
+    description: '连接 VP 账号。start 返回登录授权页，finish 交换一次性授权码；账号数据按 VP user id 分目录，disconnect 只删本地 token，不删缓存。',
+    parameters: {
+      action: { type: 'string', required: true, enum: ['start', 'finish', 'status', 'disconnect'] },
+      baseUrl: { type: 'string', description: 'VP 地址，默认 https://xiaojing.run' },
+      code: { type: 'string', description: 'VP 授权页显示的一次性 code，action=finish 时填写' },
+    },
+    output: { schema: { type: 'object', additionalProperties: false, properties: {
+      ok: { type: 'boolean', required: true }, reject: { type: 'string', required: true }, action: { type: 'string', required: true },
+      connected: { type: 'boolean', required: true }, activeAccountId: { type: 'integer', required: true },
+      account: { type: 'object', required: true, additionalProperties: false, properties: { id: { type: 'integer', required: true }, handle: { type: 'string', required: true }, display_name: { type: 'string', required: true } } }, requestId: { type: 'string', required: true },
+      authorizeUrl: { type: 'string', required: true }, expiresAt: { type: 'string', required: true }, text: { type: 'string', required: true },
+    } }, render: (_a, v) => strategyText(v) },
+    execute: async (args) => {
+      const action = String(args?.action || 'status')
+      const base = args?.baseUrl || 'https://xiaojing.run'
+      try {
+        let result
+        if (action === 'start') result = await vpClient.start({ baseUrl: base })
+        else if (action === 'finish') {
+          result = await vpClient.finish({ code: args?.code, baseUrl: base })
+          switchCoachWorkspace(result.activeAccountId)
+        } else if (action === 'disconnect') {
+          result = vpClient.disconnect()
+          switchCoachWorkspace('')
+        } else result = await vpClient.status()
+        const account = vpAccount(result.account)
+        return { ok: true, reject: '', action, connected: Boolean(result.connected ?? action === 'finish'), activeAccountId: Number(result.activeAccountId || account.id || 0), account,
+          requestId: String(result.requestId || ''), authorizeUrl: String(result.authorizeUrl || ''), expiresAt: String(result.expiresAt || ''),
+          text: action === 'start' ? `打开授权页登录 VP：${result.authorizeUrl}\n授权后把页面显示的 code 交给 coach_vp_connect finish。` :
+            action === 'finish' ? `VP 已连接：${account.handle}（账号 ${account.id}）；本地工作区已切换。` :
+              action === 'disconnect' ? 'VP 已断开；缓存保留，token 已删除。' : (result.connected ? `当前 VP：${account.handle}（账号 ${account.id}）` : '当前没有已连接的 VP 账号。') }
+      } catch (err) {
+        return { ok: false, reject: String(err?.message || err), action, connected: false, activeAccountId: 0, account: emptyVpAccount(), requestId: '', authorizeUrl: '', expiresAt: '', text: '' }
+      }
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'coach_vp_sync',
+    description: '从当前 VP 账号增量同步比赛、提交、事件和个人时间线。只读；游标和缓存都放在当前账号目录，切换账号不会读到另一人的数据。同步后自动生成带账号前缀的 VP 训练证据。',
+    parameters: {
+      limit: { type: 'integer', description: '单次最多同步多少条提交，默认 200' },
+      includeProfile: { type: 'boolean', description: '是否同步个人 rating/比赛历史，默认 true' },
+    },
+    output: { schema: { type: 'object', additionalProperties: false, properties: {
+      ok: { type: 'boolean', required: true }, reject: { type: 'string', required: true }, account: { type: 'object', required: true, additionalProperties: false, properties: { id: { type: 'integer', required: true }, handle: { type: 'string', required: true }, display_name: { type: 'string', required: true } } },
+      imported: { type: 'integer', required: true }, contests: { type: 'array', required: true }, submissions: { type: 'array', required: true }, events: { type: 'array', required: true },
+      nextCursor: { type: 'object', required: true, additionalProperties: true }, cachedPath: { type: 'string', required: true }, text: { type: 'string', required: true },
+    } }, render: (_a, v) => strategyText(v) },
+    execute: async (args) => {
+      try {
+        const payload = await vpClient.sync({ limit: args?.limit, includeProfile: args?.includeProfile !== false })
+        const account = vpAccount(payload.account)
+        switchCoachWorkspace(account.id)
+        const importedEvents = vpEventsFromSync(payload, account)
+        const imported = importedEvents.length ? strategy.vpImport(importedEvents) : { imported: 0 }
+        return { ok: true, reject: '', account, imported: Number(imported.imported || 0), contests: payload.contests || [], submissions: payload.submissions || [], events: payload.events || [],
+          nextCursor: payload.next_cursor || {}, cachedPath: String(payload.cachedPath || ''), text: `VP 同步完成：${account.handle}；比赛 ${payload.contests?.length || 0} 场，提交 ${payload.submissions?.length || 0} 条，新增训练证据 ${imported.imported || 0} 场。` }
+      } catch (err) {
+        return { ok: false, reject: String(err?.message || err), account: emptyVpAccount(), imported: 0, contests: [], submissions: [], events: [], nextCursor: {}, cachedPath: '', text: '' }
+      }
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'coach_vp_replay',
+    description: '读取当前 VP 账号指定比赛的细粒度回放。返回题目、队伍提交和秒级时间轴；代码不回传，页面可视化从这个数据绘制。',
+    parameters: { contestId: { type: 'integer', required: true }, limit: { type: 'integer', description: '官方 runs 上限，默认 50000' } },
+    output: { schema: { type: 'object', additionalProperties: false, properties: {
+      ok: { type: 'boolean', required: true }, reject: { type: 'string', required: true }, account: { type: 'object', required: true, additionalProperties: false, properties: { id: { type: 'integer', required: true }, handle: { type: 'string', required: true }, display_name: { type: 'string', required: true } } },
+      contest: { type: 'object', required: true, additionalProperties: true }, problems: { type: 'array', required: true }, result: { type: 'object', required: true, additionalProperties: true },
+      visualization: { type: 'object', required: true, additionalProperties: true }, cachedPath: { type: 'string', required: true }, text: { type: 'string', required: true },
+    } }, render: (_a, v) => strategyText(v) },
+    execute: async (args) => {
+      try {
+        const payload = await vpClient.replay({ contestId: args?.contestId, limit: args?.limit })
+        const account = vpAccount(payload.account)
+        return { ok: true, reject: '', account, contest: payload.contest || {}, problems: payload.problems || [], result: payload.result || {}, visualization: payload.visualization || {}, cachedPath: String(payload.cachedPath || ''),
+          text: `回放已加载：${payload.contest?.title || args?.contestId}；队伍事件 ${payload.visualization?.team_events?.length || 0} 个，官方 runs ${payload.visualization?.official_run_count || 0} 条。` }
+      } catch (err) {
+        return { ok: false, reject: String(err?.message || err), account: emptyVpAccount(), contest: {}, problems: [], result: {}, visualization: {}, cachedPath: '', text: '' }
+      }
+    },
+  }))
+
   ctx.tools.register(defineTool({
     name: 'coach_target',
     description: '设置或读取比赛目标。目标先于知识点：contest/date/result/teamMode/weeklyHours/priorities 都确定后，教练才有依据选训练重点。',
@@ -1865,11 +2053,11 @@ function apply(ctx) {
     },
     output: { schema: { type: 'object', additionalProperties: false, properties: {
       ok: { type: 'boolean', required: true }, reject: { type: 'string', required: true }, imported: { type: 'integer', required: true },
-      total: { type: 'integer', required: true }, revision: { type: 'integer', required: true }, text: { type: 'string', required: true },
+      total: { type: 'integer', required: true }, revision: { type: 'integer', required: true }, invalid: { type: 'array', required: true, items: { type: 'string' } }, text: { type: 'string', required: true },
       } }, render: (_a, v) => strategyText(v) },
     execute: (args) => {
       const v = strategy.vpImport(Array.isArray(args?.events) ? args.events : [])
-      return { ok: v.ok, reject: v.reject, imported: v.imported, total: v.total, revision: v.revision,
+      return { ok: v.ok, reject: v.reject, imported: v.imported, total: v.total, revision: v.revision, invalid: v.invalid ?? [],
         text: v.ok ? `✓ VP 记录已保存：本次 ${v.imported} 场，累计 ${v.total} 场，revision ${v.revision}` : '' }
     },
   }))
@@ -1901,11 +2089,32 @@ function apply(ctx) {
       ok: { type: 'boolean', required: true }, reject: { type: 'string', required: true }, contest: { type: 'string', required: true },
       deadline: { type: 'string', required: true }, focus: { type: 'array', required: true }, postponed: { type: 'array', required: true },
       evidenceEvents: { type: 'integer', required: true }, postmortems: { type: 'integer', required: true }, text: { type: 'string', required: true },
+      course: { type: 'object', required: true, additionalProperties: false, properties: {
+        exists: { type: 'boolean', required: true }, revision: { type: 'integer', required: true },
+        phaseId: { type: 'string', required: true }, phaseTitle: { type: 'string', required: true },
+        focusNodes: { type: 'array', required: true, items: { type: 'string' } }, pendingNodes: { type: 'array', required: true, items: { type: 'string' } },
+        phaseCompetencies: { type: 'array', required: true, items: { type: 'string' } },
+        focusExpired: { type: 'boolean', required: true }, missingFreshEvidence: { type: 'array', required: true, items: { type: 'string' } },
+      } },
     } }, render: (_a, v) => strategyText(v) },
     execute: () => {
       const v = strategy.focus()
-      return { ...v, text: v.ok ? [`【当前训练重点】${v.contest} · 截止 ${v.deadline}`,
+      let snapshot
+      try { snapshot = curriculum.snapshot() } catch (err) {
+        snapshot = { exists: false, revision: 0, phaseId: '', phaseTitle: '', focusNodes: [], pendingNodes: [], focusExpired: false, missingFreshEvidence: [] }
+        v.ok = false
+        v.reject = v.reject || `课程读取失败：${err.message}`
+      }
+      const course = {
+        exists: Boolean(snapshot.exists), revision: Number(snapshot.revision || 0), phaseId: String(snapshot.phaseId || ''),
+        phaseTitle: String(snapshot.phaseTitle || ''), focusNodes: snapshot.focusNodes ?? [], pendingNodes: snapshot.pendingNodes ?? [],
+        phaseCompetencies: snapshot.phaseCompetencies ?? [],
+        focusExpired: Boolean(snapshot.focusExpired), missingFreshEvidence: snapshot.missingFreshEvidence ?? [],
+      }
+      return { ...v, course, text: v.ok ? [`【当前训练重点】${v.contest} · 截止 ${v.deadline}`,
         ...v.focus.map((f, i) => `${i + 1}. ${f.title}（${f.id}）\n   比赛价值：${f.contestUse}\n   为什么现在：${f.whyNow}\n   关联知识点：${f.nodes.join('、') || '需先定义'}\n   证据次数：${f.evidenceCount}`),
+        course.exists ? `课程阶段：${course.phaseTitle}（${course.phaseId}）\n课程主线：${course.focusNodes.join('、') || '能力证据驱动'}\n比赛能力：${course.phaseCompetencies.join('、') || '地图知识点'}` : '课程阶段：尚未建立，用 coach_curriculum assess/read/create 建立长期路线。',
+        course.pendingNodes.length ? `课程未完成动作：${course.pendingNodes.join('、')}` : '',
         v.postponed.length ? `暂缓：${v.postponed.join('、')}` : '没有暂缓项。',
       ].join('\n') : '' }
     },
@@ -2681,7 +2890,9 @@ function apply(ctx) {
       '必须存在于地图、必须是当前游标的下一层、前置必须都满足。校验不过会被拒绝并说明原因。' +
       '它一次只收一个节点，所以**给不出候选列表** —— 这正是设计意图。' +
       '有长期课程时先读 coach_curriculum，带 curriculumRevision；主线必须属于当前阶段，' +
-      '补漏或复习用 purpose 与 routeReason 说明关系和回归条件。课程节点可以跨图分支，但前置检查仍生效。',
+      '补漏或复习用 purpose 与 routeReason 说明关系和回归条件。课程节点可以跨图分支，但前置检查仍生效。' +
+      '有比赛目标时，progress 动作还必须落在当前目标能力；跨重点训练只能走课程绑定，' +
+      '补漏/复习必须说明 routeReason。',
     parameters: {
       cursor: {
         type: 'string',
@@ -2740,6 +2951,8 @@ function apply(ctx) {
           pendingRecorded: { type: 'boolean', required: true },
           // 这个节点上原来就押着一条（被这次覆盖）。
           pendingReplaced: { type: 'boolean', required: true },
+          targetAligned: { type: 'boolean', required: true },
+          competencies: { type: 'array', required: true, items: { type: 'string' } },
           blocks: {
             type: 'array',
             required: true,
@@ -2778,6 +2991,7 @@ function apply(ctx) {
             v.boxNote ? `⚠️ ${v.boxNote}` : '',
             `交付物　${v.deliverable}`,
             v.why ? `为什么　${v.why}` : '',
+            v.competencies.length ? `目标对齐　✓ ${v.competencies.join('、')}` : '',
             ``,
             table,
             v.teachMinutes
@@ -2818,7 +3032,7 @@ function apply(ctx) {
         // 需求 #6：拒绝时也把这两个字段摆出来 —— 白名单式的 schema
         // （additionalProperties: false + required:true）要求每个出口同形，
         // 缺一个 verify-shape 那一关就会红。
-        pendingRecorded: false, pendingReplaced: false,
+        pendingRecorded: false, pendingReplaced: false, targetAligned: false, competencies: [],
       })
 
       // ① 游标认不认得。「没设」和「打错」分开提示，别让模型去猜。
@@ -2847,6 +3061,11 @@ function apply(ctx) {
         why = `课程「${route.binding.phaseTitle}」· ${route.binding.purpose}：${why}` +
           (route.binding.reason ? `；补充依据：${route.binding.reason}` : '')
       }
+      const targetRoute = strategy.route(node, { purpose: args?.purpose, courseBound: Boolean(route.binding) })
+      if (!targetRoute.ok) return deny(targetRoute.reject)
+      if (targetRoute.competencyIds.length) {
+        why = `目标能力「${targetRoute.competencyIds.join('、')}」：${why || '当前重点对应的训练动作'}`
+      }
 
       // ③ 未建课程时沿用直接后继；有课程时允许当前阶段跨分支，仍检查前置。
       //
@@ -2976,6 +3195,7 @@ function apply(ctx) {
         totalMinutes: net + teach + TAIL_MIN, boxNote,
         deliverable, why, mapStamp: stamp, selfTarget: node === cursor,
         pendingRecorded, pendingReplaced: replacedPending,
+        targetAligned: targetRoute.targetAligned, competencies: targetRoute.competencyIds,
         blocks: [
           // 讲解段排在最前面，`kind: teach` —— 卷面上看得见，
           // 它才不会变成"讲完就忘了排"的那个动作

package/lib/client.js

@@ -87,6 +87,7 @@ window.__ModuleLoader__.load({
     }
 
     const PAGE_URL = "/coach/skilltree.html";
+    const VP_PAGE_URL = "/coach/vp.html";
 
     // VP（CompetitionWhale）的品牌标：**拱**是露出水面的鲸背，**波浪**是水面，两笔。
     //
@@ -191,6 +192,37 @@ window.__ModuleLoader__.load({
       });
     }
 
+    function VpOverlay({ onClose }) {
+      React.useEffect(() => {
+        const onKey = (e) => { if (e.key === "Escape") onClose(); };
+        document.addEventListener("keydown", onKey);
+        return () => document.removeEventListener("keydown", onKey);
+      }, [onClose]);
+      return jsx("div", {
+        className: "dshcoach-mask",
+        onClick: (e) => { if (e.target === e.currentTarget) onClose(); },
+        children: jsxs("div", {
+          className: "dshcoach-panel",
+          children: [
+            jsxs("div", { className: "dshcoach-bar", children: [
+              jsxs("div", { className: "dshcoach-title", children: [jsx(WhaleMark, { size: 17 }), jsx("span", { children: "VP 回放" })] }),
+              jsx("button", { type: "button", className: "dshcoach-action", onClick: () => window.open(VP_PAGE_URL, "_blank", "noopener"), children: "新标签页打开" }),
+              jsx("button", { type: "button", className: "dshcoach-action", onClick: onClose, children: "✕ 关闭" }),
+            ] }),
+            jsx("iframe", { className: "dshcoach-frame", src: VP_PAGE_URL, title: "VP 回放" }),
+          ],
+        }),
+      });
+    }
+
+    function VpHeaderButton() {
+      const [open, setOpen] = React.useState(false);
+      return jsxs(React.Fragment, { children: [
+        jsxs("button", { type: "button", className: "dshcoach-btn", title: "连接 VP、同步比赛并查看秒级回放", onClick: () => setOpen(true), children: [jsx(WhaleMark, { size: 15 }), jsx("span", { children: "VP 回放" })] }),
+        open ? createPortal(jsx(VpOverlay, { onClose: () => setOpen(false) }), document.body) : null,
+      ] });
+    }
+
     // 服务名注入（不是模块名）：等 slots 服务到位再注册。
     const inject = ["slots"];
 
@@ -202,6 +234,12 @@ window.__ModuleLoader__.load({
         order: 20,
         registrant: "acmer-coach",
       }, SkillTreeHeaderButton));
+      ctx.slots.inject("conversation.session.header.utilities", () => ctx.slots.register({
+        name: "conversation.session.header.utilities",
+        id: "acmer-coach:vp",
+        order: 21,
+        registrant: "acmer-coach",
+      }, VpHeaderButton));
     }
 
     return { apply, inject };

package/lib/curriculum-planning.js

@@ -4,7 +4,7 @@ const text = (value, field, phase) => {
   if (result.length < 10) throw new Error(`阶段 ${phase} 的 ${field} 需要至少 10 字的具体依据。`)
   return result
 }
-const coreKeys = ['id', 'title', 'outcome', 'nodes', 'exitCriteria', 'requiredVerified']
+const coreKeys = ['id', 'title', 'outcome', 'nodes', 'competencies', 'exitCriteria', 'requiredVerified']
 export const corePhase = (phase) => Object.fromEntries(coreKeys.map((key) => [key, phase[key]]))
 
 export function prerequisitesOf(nodes, byId) {
@@ -37,6 +37,7 @@ export function normalizePhases(input, byId, { legacy = false, completed = [] }
     const p = {
       id: clean(phase?.id), title: clean(phase?.title), outcome: clean(phase?.outcome),
       nodes: Array.isArray(phase?.nodes) ? phase.nodes.map(clean) : [],
+      competencies: Array.isArray(phase?.competencies) ? [...new Set(phase.competencies.map(clean).filter(Boolean))] : [],
       exitCriteria: clean(phase?.exitCriteria),
       requiredVerified: Array.isArray(phase?.requiredVerified) ? phase.requiredVerified.map(clean)
         : (kind === 'training' || kind === 'legacy' ? [...(phase?.nodes ?? [])].map(clean) : []),
@@ -44,7 +45,7 @@ export function normalizePhases(input, byId, { legacy = false, completed = [] }
     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} 缺标题、能力成果或验收条件。`)
-    if (!p.nodes.length || p.nodes.length > 50 || new Set(p.nodes).size !== p.nodes.length) throw new Error(`阶段 ${p.id} 需要 1–50 个不重复的地图节点。`)
+    if ((!p.nodes.length && !p.competencies.length) || p.nodes.length > 50 || new Set(p.nodes).size !== p.nodes.length) throw new Error(`阶段 ${p.id} 至少需要一个地图节点或比赛能力，地图节点最多 50 个。`)
     for (const node of p.nodes) if (!byId.has(node)) throw new Error(`阶段 ${p.id} 的节点「${node}」不在地图里。`)
     if (new Set(p.requiredVerified).size !== p.requiredVerified.length || p.requiredVerified.some((node) => !p.nodes.includes(node))) throw new Error(`阶段 ${p.id} 的必验节点必须属于该阶段，且不能重复。`)
     const prerequisites = prerequisitesOf(p.nodes, byId)
@@ -85,7 +86,9 @@ export function validatePlan(phases, { byId, progress, catalog, current = 0 }) {
     for (const ref of phase.evidenceRefs) {
       const entry = records.get(ref)
       if (!entry) throw new Error(`阶段 ${phase.id} 的证据不存在或内容已变：${ref}。先 assess 重新取引用。`)
-      if (!phase.nodes.includes(entry.node)) throw new Error(`阶段 ${phase.id} 引用了无关节点「${entry.node}」的记录。`)
+      const nodeMatch = entry.node && phase.nodes.includes(entry.node)
+      const competencyMatch = entry.competency && phase.competencies.includes(entry.competency)
+      if (!nodeMatch && !competencyMatch) throw new Error(`阶段 ${phase.id} 引用了无关的证据记录「${ref}」。`)
     }
     if (phase.kind !== 'training') continue
     const signal = phase.finding === 'gap' ? 'gap' : 'baseline'
@@ -94,6 +97,11 @@ export function validatePlan(phases, { byId, progress, catalog, current = 0 }) {
       return entry.node === node && entry.signal === signal
     }))
     if (uncovered.length) throw new Error(`阶段 ${phase.id} 的${signal === 'gap' ? '短板' : '进阶起点'}缺真实依据：${uncovered.join('、')}。先诊断；rating、状态或一段理由不能代替记录。`)
+    const missingCompetencies = phase.competencies.filter((competency) => !phase.evidenceRefs.some((ref) => {
+      const entry = records.get(ref)
+      return entry.competency === competency && entry.signal === signal
+    }))
+    if (missingCompetencies.length) throw new Error(`阶段 ${phase.id} 的${signal === 'gap' ? '短板' : '进阶起点'}缺真实能力依据：${missingCompetencies.join('、')}。先记录 VP 或复盘，不用 rating 代替。`)
     // 同阶段节点按依赖顺序列出；只有前阶段的必验训练节点能作为未来前置。
     for (const node of phase.nodes) {
       const missing = prerequisitesOf([node], byId).filter((dependency) => !available.has(dependency))
@@ -106,6 +114,9 @@ export function validatePlan(phases, { byId, progress, catalog, current = 0 }) {
 export function missingFreshEvidence(phase, catalog, entryEvidenceRefs, enteredDate, entryEvidenceEvents = []) {
   const old = new Set(entryEvidenceRefs)
   const events = new Set(entryEvidenceEvents)
-  return phase.nodes.filter((node) => !catalog.some((entry) => entry.node === node && !old.has(entry.id) &&
+  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')))
+  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')))
+  return [...missingNodes, ...missingCompetencies]
 }