acmer-coach 1.2.1 → 2.1.0

package/index.js

@@ -23,18 +23,19 @@
 //   · `file:` 依赖装出来的是**硬链接**，不是拷贝。原地写两边同变，但改名式
 //     写入（Edit 工具、VS Code 原子保存）会**断开链接**，断了两边分家，
 //     而 `dsh plugin add` 认不出分家、不重链也不报错 —— 所以改完一律跑 dev.sh。
-import { readFileSync, writeFileSync, renameSync, statSync } from 'node:fs'
+import { copyFileSync, readFileSync, unlinkSync, writeFileSync, renameSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 import { parse, stringify } from 'yaml'
 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'
 
 const name = 'acmer-coach'
 const inject = ['tools']
 
-const VERSION = '1.2.1'
+const VERSION = '2.1.0'
 
 // 块结构（方针 §4.1.1）：40 自己做 + 10 解决遗留 + 10 重写 = 60 分钟。
 // 这是**一个题目循环**的固定形状。时间不够该换更小的题，不是把块压扁。
@@ -70,7 +71,14 @@ 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'),
+})
+const curriculum = createCurriculumStore({
+  dataDir: DATA_DIR, loadMap, loadProgress, loadSchedule,
+  loadStrategyEvidence: () => strategy.evidence().evidence,
+})
 
 // 探针要的文件，各自代表一条后面的依赖：
 //   MAP.yaml      地图（coach_next 读它算候选）
@@ -251,6 +259,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)` 一把梭 ——
@@ -271,7 +289,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
 }
 
@@ -365,7 +383,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
 }
 
@@ -1602,12 +1620,15 @@ function registerStateHook(ctx) {
       // 课程可以先于游标存在；即使尚未布置动作，也要在新会话继续同一路线。
       let hasCurriculum = false
       try { hasCurriculum = Boolean(curriculum.load()) } catch { hasCurriculum = true }
-      if (!cursor && !pending && !studying.length && !hasCurriculum) return decision
+      let hasTarget = false
+      try { hasTarget = Boolean(strategy.loadTarget().contest) } catch { hasTarget = true }
+      if (!cursor && !pending && !studying.length && !hasCurriculum && !hasTarget) return decision
 
       const { byId } = loadMap()
       const nameOf = (id) => byId.get(String(id))?.name ?? String(id)
       const node = byId.get(cursor)
       const lines = ['<coach_state>', '（教练插件注入的位置，不用再调工具问）']
+      lines.push(strategy.context())
       lines.push(curriculum.context())
       lines.push(cursor
         ? `- 游标：${nameOf(cursor)}（${cursor}）${node?.domain ? `　[${node.domain}]` : ''}`
@@ -1813,6 +1834,137 @@ function apply(ctx) {
 
   ctx.tools.register(defineTool(curriculumTool(curriculum)))
 
+  // ── 目标驱动策略层：比赛目标 / VP 证据 / 复盘 / 当前重点 ─────────
+  // 课程图回答“有哪些知识点”，策略层回答“为什么现在学这个”。两者分开，
+  // 避免把 rating 或游标误当成区域赛目标。
+  const strategyText = (v) => [{ type: 'text', text: v.ok ? v.text : `❌ ${v.reject}` }]
+  ctx.tools.register(defineTool({
+    name: 'coach_target',
+    description: '设置或读取比赛目标。目标先于知识点：contest/date/result/teamMode/weeklyHours/priorities 都确定后，教练才有依据选训练重点。',
+    parameters: {
+      action: { type: 'string', required: true, enum: ['read', 'set', 'clear'] },
+      expectedRevision: { type: 'integer', description: 'read 返回的 revision；首次 set 用 0。' },
+      contest: { type: 'string', description: '比赛名称，例如西安区域赛' },
+      date: { type: 'string', description: '比赛日期 YYYY-MM-DD' },
+      result: { type: 'string', description: '目标结果，例如区域赛金牌' },
+      teamMode: { type: 'string', description: 'solo 或 team' },
+      weeklyHours: { type: 'number', description: '每周可用训练小时' },
+      constraints: { type: 'object', additionalProperties: true, description: '可选时间约束，例如 weekday/saturday/sunday' },
+      priorities: { type: 'array', description: '能力优先级 [{id, weight, reason}]，weight 越大越优先', items: { type: 'object', additionalProperties: false, properties: {
+        id: { type: 'string', required: true }, weight: { type: 'number', required: true }, reason: { type: 'string' },
+      } } },
+    },
+    output: { schema: { type: 'object', additionalProperties: false, properties: {
+      ok: { type: 'boolean', required: true }, reject: { type: 'string', required: true }, revision: { type: 'integer', required: true },
+      contest: { type: 'string', required: true }, date: { type: 'string', required: true }, result: { type: 'string', required: true },
+      teamMode: { type: 'string', required: true }, weeklyHours: { type: 'number', required: true }, priorities: { type: 'array', required: true },
+      updated: { type: 'string', required: true }, version: { type: 'integer', required: true },
+      constraints: { type: 'object', required: true, additionalProperties: true }, text: { type: 'string', required: true },
+    } }, render: (_a, v) => strategyText(v) },
+    execute: (args) => {
+      const v = strategy.target(args?.action || 'read', args ?? {})
+      return { ...v, text: v.ok
+        ? `【比赛目标 · revision ${v.revision}】${v.contest} / ${v.date}\n目标：${v.result}\n模式：${v.teamMode}；每周 ${v.weeklyHours} 小时\n能力重点：${v.priorities.map((p) => `${p.id}(${p.weight})`).join('、')}`
+        : '' }
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'coach_vp_import',
+    description: '导入 VP 或模拟赛记录。它保存比赛过程证据，让教练根据读题、耗时、提交和题目选择复盘，不再只看 CF rating。重复 eventId 会更新，不会重复堆积。',
+    parameters: {
+      events: { type: 'array', required: true, items: { type: 'object', additionalProperties: true,
+        description: '每场含 eventId/contest/date/problems；problem 含 problemId/status/readMinutes/solveMinutes/attempts/competencies' } },
+    },
+    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 }, 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, invalid: v.invalid ?? [],
+        text: v.ok ? `✓ VP 记录已保存：本次 ${v.imported} 场，累计 ${v.total} 场，revision ${v.revision}` : '' }
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'coach_postmortem',
+    description: '记录一场 VP 的赛后复盘。至少写能力问题、根因或下一步动作之一；复盘会影响 coach_focus 的优先级。',
+    parameters: {
+      eventId: { type: 'string', required: true }, competencies: { type: 'array', items: { type: 'string' } },
+      missedReads: { type: 'array', items: { type: 'string' } }, decisionErrors: { type: 'array', items: { type: 'string' } },
+      teamIssues: { type: 'array', items: { type: 'string' } }, rootCauses: { type: 'array', items: { type: 'string' } },
+      nextActions: { type: 'array', items: { type: 'string' } }, note: { type: 'string' }, date: { type: 'string' },
+    },
+    output: { schema: { type: 'object', additionalProperties: false, properties: {
+      ok: { type: 'boolean', required: true }, reject: { type: 'string', required: true }, eventId: { type: 'string', required: true },
+      revision: { type: 'integer', required: true }, postmortems: { type: 'array', required: true }, text: { type: 'string', required: true },
+    } }, render: (_a, v) => strategyText(v) },
+    execute: (args) => {
+      const v = strategy.postmortem(args ?? {})
+      return { ...v, text: v.ok ? `✓ 已记录 ${v.eventId} 的复盘；当前共 ${v.postmortems.length} 条复盘，revision ${v.revision}` : '' }
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'coach_focus',
+    description: '根据比赛目标权重和 VP 复盘证据生成当前训练重点。它输出能力、比赛价值、为什么现在学、关联知识点和暂缓项；没有目标时拒绝猜方向。',
+    parameters: {},
+    output: { schema: { type: 'object', additionalProperties: false, properties: {
+      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()
+      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') : '' }
+    },
+  }))
+
+  ctx.tools.register(defineTool({
+    name: 'coach_scope',
+    description: '查看一个比赛能力或知识点的适用范围、延伸、反例、常见错误、迁移题和退出条件。没有范围卡片时明确拒绝编造。',
+    parameters: { id: { type: 'string', required: true, description: '能力 id 或地图节点 id' } },
+    output: { schema: { type: 'object', additionalProperties: false, properties: {
+      ok: { type: 'boolean', required: true }, reject: { type: 'string', required: true }, found: { type: 'boolean', required: true },
+      id: { type: 'string', required: true }, title: { type: 'string', required: true }, contestUse: { type: 'string', required: true },
+      nodes: { type: 'array', required: true }, appliesTo: { type: 'array', required: true }, extensions: { type: 'array', required: true }, notFor: { type: 'array', required: true },
+      commonFailures: { type: 'array', required: true }, transferProblems: { type: 'array', required: true }, exitEvidence: { type: 'array', required: true },
+      text: { type: 'string', required: true },
+    } }, render: (_a, v) => strategyText(v) },
+    execute: (args) => {
+      const v = strategy.scope(args?.id)
+      return { ...v, text: v.ok ? [`【范围卡片】${v.title}（${v.id}）`, `比赛价值：${v.contestUse}`,
+        `适用：${v.appliesTo.join('、')}`, `延伸：${v.extensions.join('、')}`, `不要用于：${v.notFor.join('、')}`,
+        `常见错误：${v.commonFailures.join('、')}`, `迁移：${v.transferProblems.join('、')}`, `退出条件：${v.exitEvidence.join('、')}`,
+      ].join('\n') : '' }
+    },
+  }))
+
   ctx.tools.register(defineTool({
     name: 'coach_setup',
     description:
@@ -2563,7 +2715,9 @@ function apply(ctx) {
       '必须存在于地图、必须是当前游标的下一层、前置必须都满足。校验不过会被拒绝并说明原因。' +
       '它一次只收一个节点，所以**给不出候选列表** —— 这正是设计意图。' +
       '有长期课程时先读 coach_curriculum，带 curriculumRevision；主线必须属于当前阶段，' +
-      '补漏或复习用 purpose 与 routeReason 说明关系和回归条件。课程节点可以跨图分支，但前置检查仍生效。',
+      '补漏或复习用 purpose 与 routeReason 说明关系和回归条件。课程节点可以跨图分支，但前置检查仍生效。' +
+      '有比赛目标时，progress 动作还必须落在当前目标能力；跨重点训练只能走课程绑定，' +
+      '补漏/复习必须说明 routeReason。',
     parameters: {
       cursor: {
         type: 'string',
@@ -2622,6 +2776,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,
@@ -2660,6 +2816,7 @@ function apply(ctx) {
             v.boxNote ? `⚠️ ${v.boxNote}` : '',
             `交付物　${v.deliverable}`,
             v.why ? `为什么　${v.why}` : '',
+            v.competencies.length ? `目标对齐　✓ ${v.competencies.join('、')}` : '',
             ``,
             table,
             v.teachMinutes
@@ -2700,7 +2857,7 @@ function apply(ctx) {
         // 需求 #6：拒绝时也把这两个字段摆出来 —— 白名单式的 schema
         // （additionalProperties: false + required:true）要求每个出口同形，
         // 缺一个 verify-shape 那一关就会红。
-        pendingRecorded: false, pendingReplaced: false,
+        pendingRecorded: false, pendingReplaced: false, targetAligned: false, competencies: [],
       })
 
       // ① 游标认不认得。「没设」和「打错」分开提示，别让模型去猜。
@@ -2729,6 +2886,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 || '当前重点对应的训练动作'}`
+      }
 
       // ③ 未建课程时沿用直接后继；有课程时允许当前阶段跨分支，仍检查前置。
       //
@@ -2858,6 +3020,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/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]
 }

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