acmer-coach 2.0.0 → 2.1.0

package/README.md

@@ -75,7 +75,7 @@ VP 记录格式是 JSON 数组，每场至少包含 `eventId`、`contest`、`dat
 ### 长期学习路线
 
 `coach_curriculum assess` 从已有检测、代码判因、做题记录和日程实际完成中列出
-可引用的证据；不会把 rating、学习状态或取消的卷子当成短板。每条记录带内容引用
+可引用的证据；VP 题目与复盘里的 `competencies` 也会生成稳定证据 id，不会把 rating、学习状态或取消的卷子当成短板。每条记录带内容引用
 `id` 和事件身份 `eventId`。训练阶段的每个节点必须有真实记录：`finding=gap`
 引用失败/超时/依赖提示等短板，`finding=extension` 引用已独立做出或过卷的能力起点。
 
@@ -86,8 +86,7 @@ VP 记录格式是 JSON 数组，每场至少包含 `eventId`、`contest`、`dat
 learned/verified 记录，或路线中在此前安排的必验训练，不能从游标位置推定已经学会。
 
 `CURRICULUM.yaml` 保存路线与修订历史：`read` 查看，`create` 建立，`revise` 调整，
-`advance` 推进。进入阶段时保存证据事件快照；诊断阶段每个节点需有新的真实观察，
-训练阶段所有节点必须 verified，且各有新的独立做出或过卷记录。改旧备注、成绩或
+`advance` 推进。阶段可以只绑定比赛能力（读题、决策、团队沟通），这类阶段用 VP/复盘证据验收，不必伪装成地图节点。进入阶段时保存证据事件快照；诊断阶段每个节点需有新的真实观察，训练阶段所有节点必须 verified，能力目标必须有阶段后的新 baseline 证据。改旧备注、成绩或
 把同次做题从课表迁入进度，不算新训练。当前诊断也不能通过改种类或删节点逃过验收。
 写操作带 `expectedRevision` 和理由，避免旧上下文覆盖新计划。
 路线按剩余 `estimatedHours`、每周预算和目标日期提示容量不足或估算缺失；这只是

package/assets/rules/coach-rules.md

@@ -30,7 +30,7 @@
   必须填写 `basis`、`goalContribution`、`priorityReason`、`estimatedHours`、
   `evidenceRefs`、`finding`、`kind`、`uncertainty`、`diagnosticMethod`。
   说清观察到了什么、它怎样服务目标、为何排在这里、预计投入多少，不套统一算法清单。
-* `kind=training` 的每个节点都要对应真实证据：补短板用 `finding=gap`，引用 gap；
+* `kind=training` 的每个节点都要对应真实证据：补短板用 `finding=gap`，引用 gap；读题、决策、团队沟通这类没有单一地图节点的阶段改用 `competencies`，引用 VP/复盘产生的能力证据；
   在已证实能力上进阶用 `finding=extension`，引用 baseline。记录指向什么由你解读，
   但**不能写一段理由替代不存在的记录**，也不能把别的节点的失败贴来凑依据。
 * 缺依据先安排 `kind=diagnostic/finding=unknown`，写尚待确认的问题和具体取证方法。

package/dev/curriculum-check.mjs

@@ -336,6 +336,26 @@ test('broken course is surfaced and never treated as an empty plan', () => {
   assert.equal(readFileSync(f.store.path, 'utf8'), 'revision: broken\n')
 })
 
+test('competency-only phases can use fresh VP evidence as their exit gate', () => {
+  const f = fixture()
+  const evidence = [{ id: 'vp:old:contest-reading', eventId: 'old', source: 'vp', node: '', competency: 'contest-reading', date: '2026-10-08', signal: 'gap', summary: 'VP 读题漏读', fingerprint: 'vp:old:contest-reading' }]
+  f.options.loadStrategyEvidence = () => evidence
+  const store = createCurriculumStore(f.options)
+  const phase = {
+    id: 'reading', title: '比赛读题与筛选', outcome: '在前30分钟完成扫描并记录取舍', competencies: ['contest-reading'], nodes: [],
+    exitCriteria: '两场新 VP 都有扫描顺序、取舍理由和漏读检查', requiredVerified: [], kind: 'training', finding: 'gap',
+    basis: 'VP 已记录读题缺口，需要在真实比赛节奏中修复', goalContribution: '提高区域赛前半小时的可做题识别和取舍质量',
+    priorityReason: '它直接决定队伍是否把时间用在能拿分的题上', estimatedHours: 6, uncertainty: '', diagnosticMethod: '',
+    evidenceRefs: ['vp:old:contest-reading'],
+  }
+  assert.equal(store.execute({ action: 'create', expectedRevision: 0, goal: '区域赛稳定表现', baseline: '已有一场 VP 的读题缺口记录', weeklyHours: 30, phases: [phase], reason: '根据 VP 的读题记录建立能力课程' }).ok, true)
+  assert.deepEqual(store.snapshot().phaseCompetencies, ['contest-reading'])
+  assert.deepEqual(store.snapshot().missingFreshEvidence, ['contest-reading'])
+  evidence.push({ id: 'vp:new:contest-reading', eventId: 'new', source: 'vp', node: '', competency: 'contest-reading', date: '2026-10-09', signal: 'baseline', summary: '新 VP 读题记录', fingerprint: 'vp:new:contest-reading' })
+  assert.deepEqual(store.snapshot().missingFreshEvidence, [])
+  assert.equal(store.execute({ action: 'advance', expectedRevision: 1, reason: '新 VP 已记录扫描顺序和取舍理由，满足本阶段能力验收' }).status, 'complete')
+})
+
 test('course tool output matches its declared schema on success, rejection and absence', () => {
   const f = fixture(); const tool = curriculumTool(f.store)
   for (const result of [f.store.execute({ action: 'read' }), f.create(), f.store.execute({ action: 'advance', expectedRevision: 1, reason: '检查未验收阶段是否能够被强行推进' })]) validateShape(tool.output.schema, result)

package/dev/strategy-check.mjs

@@ -1,11 +1,12 @@
 import test from 'node:test'
 import assert from 'node:assert/strict'
-import { mkdtempSync, rmSync, existsSync } from 'node:fs'
+import { mkdtempSync, rmSync, existsSync, writeFileSync } from 'node:fs'
 import { join } from 'node:path'
+import { tmpdir } from 'node:os'
 import { createStrategyStore } from '../lib/strategy.js'
 
 function fixture() {
-  const dir = mkdtempSync(join(process.cwd(), '.strategy-test-'))
+  const dir = mkdtempSync(join(tmpdir(), 'acmer-coach-strategy-'))
   const store = createStrategyStore({
     dataDir: dir,
     competenciesPath: join(process.cwd(), 'assets', 'knowledge', 'COMPETENCIES.yaml'),
@@ -73,3 +74,85 @@ test('first-use focus has a complete refusal shape and targets reject unknown ca
     assert.equal(rejected.ok, false)
   } finally { rmSync(dir, { recursive: true, force: true }) }
 })
+
+test('target route rejects an unrelated progress node but allows a course-bound route', () => {
+  const { dir, store } = fixture()
+  try {
+    store.target('set', {
+      expectedRevision: 0, contest: '西安区域赛', date: '2026-10-18', result: '区域赛金牌',
+      weeklyHours: 35, priorities: [{ id: 'dp-modeling', weight: 100 }],
+    })
+    const unrelated = store.route('树状数组', { purpose: 'progress', courseBound: false })
+    assert.equal(unrelated.ok, false)
+    assert.match(unrelated.reject, /dp-modeling|当前重点/)
+    const courseBound = store.route('树状数组', { purpose: 'progress', courseBound: true })
+    assert.equal(courseBound.ok, true)
+    assert.equal(courseBound.courseBound, true)
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
+test('VP problem competencies count as evidence before a postmortem exists', () => {
+  const { dir, store } = fixture()
+  try {
+    store.target('set', {
+      expectedRevision: 0, contest: '西安区域赛', date: '2026-10-18', result: '区域赛金牌',
+      weeklyHours: 35, priorities: [
+        { id: 'dp-modeling', weight: 80 },
+        { id: 'contest-reading', weight: 70 },
+      ],
+    })
+    store.vpImport([{ eventId: 'vp-2', contest: '训练 VP', date: '2026-10-10', durationMinutes: 300,
+      problems: [{ problemId: 'B', status: 'WA', competencies: ['dp-modeling'] }] }])
+    const focus = store.focus()
+    assert.equal(focus.focus[0].id, 'dp-modeling')
+    assert.equal(focus.focus[0].evidenceCount, 1)
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
+test('strategy exposes stable competency evidence for curriculum gates', () => {
+  const { dir, store } = fixture()
+  try {
+    store.vpImport([{ eventId: 'vp-evidence', contest: '训练 VP', date: '2026-10-10', durationMinutes: 300,
+      problems: [{ problemId: 'C', status: 'WA', competencies: ['contest-decision'] }] }])
+    const result = store.evidence()
+    assert.equal(result.ok, true)
+    assert.equal(result.evidence[0].id, 'vp:vp-evidence:C:contest-decision')
+    assert.equal(result.evidence[0].signal, 'gap')
+    assert.equal(result.evidence[0].competency, 'contest-decision')
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
+test('invalid VP input is rejected without bumping revision', () => {
+  const { dir, store } = fixture()
+  try {
+    const result = store.vpImport([{ eventId: '', contest: '坏记录', date: '2026-10-10', problems: [] }])
+    assert.equal(result.ok, false)
+    assert.equal(result.revision, 0)
+    assert.equal(result.imported, 0)
+    assert.equal(result.invalid.length, 1)
+    assert.equal(existsSync(join(dir, 'VP_EVENTS.yaml')), false)
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
+test('invalid target priorities are rejected instead of silently dropped', () => {
+  const { dir, store } = fixture()
+  try {
+    const result = store.target('set', {
+      expectedRevision: 0, contest: '西安区域赛', date: '2026-10-18', result: '区域赛金牌',
+      weeklyHours: 35, priorities: [{ id: 'dp-modeling', weight: 'bad' }],
+    })
+    assert.equal(result.ok, false)
+    assert.match(result.reject, /priorit|weight|能力/)
+    assert.equal(result.revision, 0)
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
+test('corrupt stored strategy data returns a structured refusal', () => {
+  const { dir, store } = fixture()
+  try {
+    writeFileSync(join(dir, 'TARGET.yaml'), 'version: 1\nrevision: 4\npriorities: bad\n', 'utf8')
+    const result = store.target('read')
+    assert.equal(result.ok, false)
+    assert.match(result.reject, /TARGET.yaml/)
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})

package/docs//351/225/277/346/234/237/350/257/276/347/250/213/346/234/272/345/210/266.md

@@ -59,8 +59,11 @@ assess 最多返回最后 200 条，并给出 `evidenceCount/evidenceTruncated`
 
 ## 阶段如何编排
 
-基础字段 `id/title/outcome/nodes/exitCriteria` 分别标识阶段、能力成果、地图节点和
-验收方法；一个阶段 1–50 个不重复的真实节点，整条路线 1–30 个阶段。还必须提供：
+基础字段 `id/title/outcome/nodes/competencies/exitCriteria` 分别标识阶段、能力成果、地图节点、比赛能力和验收方法；一个阶段至少绑定一个真实地图节点或比赛能力，地图节点最多 50 个，整条路线 1–30 个阶段。读题、决策、团队沟通这类没有单一算法节点的阶段直接填 `competencies`。
+
+VP 题目里的 `competencies` 和复盘里的 `competencies` 会生成稳定证据 id（如 `vp:event:problem:competency`），进入课程时被快照；能力阶段只能用进入阶段后的新 baseline 记录通过 `advance`。
+
+还必须提供：
 
 | 字段 | 要回答的问题 |
 |---|---|
@@ -76,7 +79,7 @@ assess 最多返回最后 200 条，并给出 `evidenceCount/evidenceTruncated`
 
 三种可编排阶段：
 
-* **training**：每个节点都必须有对应证据。`finding=gap` 必须引用该节点的 gap；
+* **training**：每个节点或比赛能力都必须有对应证据。`finding=gap` 必须引用该节点/能力的 gap；
   `finding=extension` 必须引用该节点的 baseline。无关节点的失败不能用来凑依据。
   所有节点都必须列入 `requiredVerified`，不能用空数组逃过检测。
 * **diagnostic**：`finding=unknown`，明确待确认问题、取证方法与能力目标的关系。
@@ -111,7 +114,7 @@ assess 最多返回最后 200 条，并给出 `evidenceCount/evidenceTruncated`
 进入阶段时保存 `enteredAt/entryEvidenceRefs/entryEvidenceEvents`。advance 必须同时满足：
 
 * diagnostic：每个节点都有进入时未出现、日期不早于进入日的新有效观察。
-* training：全部节点 verified，且每个节点有本阶段新的独立做出或检测 passed 事件。
+* training：地图节点全部 verified，且每个节点有本阶段新的独立做出或检测 passed 事件；能力目标全部有本阶段新的 baseline 证据。
 * 当前阶段没有待完成动作，也没有检测卷等待判定。
 
 旧记录改内容或换来源不能替代新事件。诊断阶段不能通过 revise 改成训练或删除待诊断

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, readFileSync, unlinkSync, writeFileSync, renameSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import { homedir } from 'node:os'
 import { parse, stringify } from 'yaml'
@@ -35,7 +35,7 @@ import { createStrategyStore } from './lib/strategy.js'
 const name = 'acmer-coach'
 const inject = ['tools']
 
-const VERSION = '2.0.0'
+const VERSION = '2.1.0'
 
 // 块结构（方针 §4.1.1）：40 自己做 + 10 解决遗留 + 10 重写 = 60 分钟。
 // 这是**一个题目循环**的固定形状。时间不够该换更小的题，不是把块压扁。
@@ -71,11 +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 读它算候选）
@@ -256,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)` 一把梭 ——
@@ -276,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
 }
 
@@ -370,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
 }
 
@@ -1865,11 +1878,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 +1914,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 +2715,9 @@ function apply(ctx) {
       '必须存在于地图、必须是当前游标的下一层、前置必须都满足。校验不过会被拒绝并说明原因。' +
       '它一次只收一个节点，所以**给不出候选列表** —— 这正是设计意图。' +
       '有长期课程时先读 coach_curriculum，带 curriculumRevision；主线必须属于当前阶段，' +
-      '补漏或复习用 purpose 与 routeReason 说明关系和回归条件。课程节点可以跨图分支，但前置检查仍生效。',
+      '补漏或复习用 purpose 与 routeReason 说明关系和回归条件。课程节点可以跨图分支，但前置检查仍生效。' +
+      '有比赛目标时，progress 动作还必须落在当前目标能力；跨重点训练只能走课程绑定，' +
+      '补漏/复习必须说明 routeReason。',
     parameters: {
       cursor: {
         type: 'string',
@@ -2740,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,
@@ -2778,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
@@ -2818,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: [],
       })
 
       // ① 游标认不认得。「没设」和「打错」分开提示，别让模型去猜。
@@ -2847,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 || '当前重点对应的训练动作'}`
+      }
 
       // ③ 未建课程时沿用直接后继；有课程时允许当前阶段跨分支，仍检查前置。
       //
@@ -2976,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 ? '本周主线到期，先复盘并修订。' : '',

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/package.json

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

package/verify-shape.mjs

@@ -169,6 +169,11 @@ 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_postmortem', { eventId: 'shape-vp', competencies: ['contest-reading'], rootCauses: ['测试复盘'], nextActions: ['测试动作'] }],
   ['coach_focus', {}],
@@ -298,6 +303,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 = ''