acmer-coach 1.2.1 → 2.0.0

package/README.md

@@ -20,7 +20,7 @@
 
 ## 它到底做了什么
 
-21 个工具，两条轴：
+26 个工具，三条轴：知识图、比赛能力、训练证据。
 
 | 轴 | 含义 |
 |---|---|
@@ -45,10 +45,33 @@ coach_log       过了 → 记一条，然后夸
 coach_pool → coach_test → coach_grade    章节检测，过了才标「已验证」
   ↓
 coach_schedule → coach_plan              排课
+  ↓
+coach_target → coach_vp_import → coach_postmortem → coach_focus
+  ↓                         比赛目标、VP 复盘、当前重点
+coach_scope                  适用范围、延伸、反例、退出条件
 ```
 
 `coach_wiki` 是知识来源：讲任何知识点之前先查本地 OI Wiki，**别凭记忆讲**。
 
+### 目标驱动训练
+
+知识图只回答“有哪些知识点”，不回答“为什么现在学它”。先用
+`coach_target` 设置比赛、日期、目标结果、团队模式、可用时间和能力优先级，
+再用 `coach_vp_import` 导入 VP，`coach_postmortem` 写复盘，`coach_focus` 计算当前
+训练重点。每次布置都要能说清楚它服务哪个比赛能力、适用范围、迁移题和退出条件。
+
+VP 记录格式是 JSON 数组，每场至少包含 `eventId`、`contest`、`date` 和 `problems`：
+
+```json
+[{"eventId":"vp-西安-01","contest":"区域赛 VP","date":"2026-10-10",
+  "durationMinutes":300,"teamMode":"team","problems":[
+    {"problemId":"A","status":"AC","readMinutes":8,"solveMinutes":22,
+     "attempts":1,"competencies":["contest-reading"]}]}]
+```
+
+`coach_scope` 会返回一个能力或知识点的适用范围、延伸、反例、常见错误、迁移题
+和退出条件。没有人工范围卡片时它会明确拒绝编造，避免把“讲过”误当成“会用”。
+
 ### 长期学习路线
 
 `coach_curriculum assess` 从已有检测、代码判因、做题记录和日程实际完成中列出
@@ -70,14 +93,15 @@ learned/verified 记录，或路线中在此前安排的必验训练，不能从
 路线按剩余 `estimatedHours`、每周预算和目标日期提示容量不足或估算缺失；这只是
 调整范围的提示，不会把周平均当成精确日程，也不阻止执行。
 
-每轮注入长期目标、当前阶段和未完成单元。`coach_assign` 带课程版本，普通训练
+每轮注入比赛目标、能力重点、长期阶段和未完成单元。`coach_assign` 带课程版本，普通训练
 限于当前主线；补漏/复习需声明目的和返回依据。完成记录仍归原进度文件，
 不会因一题 AC 或日历到期自动跳阶段。没有建立课程的用户保持原有工具行为。
 
 本周主线可设置 `focusUntil`，到期先复盘修订。路线不提前占用数月日程，
 `coach_plan` 继续管理近期时间块。旧 v1 路线可读，会标记 `needsReview`；需明确
 修订当前及后续阶段后迁移 v2，插件不会自动重写。优先级与教学方案仍由模型判断，
-程序只检查证据、前置和验收边界。本功能没有新增 VP 自动读取或后台周报。
+程序现在会要求目标和 VP 证据先进入策略层；能力卡片仍由仓库维护，未知卡片不会自动臆造。
+这版仍不包含后台定时同步和自动读取第三方 VP 网站，导出后用 `coach_vp_import` 导入。
 详见 [长期课程机制](docs/长期课程机制.md)。
 
 **「学过」和「已验证」是两级，绝不合并。** 自评 ≠ 掌握 ——

package/assets/knowledge/COMPETENCIES.yaml

@@ -0,0 +1,92 @@
+version: 1
+competencies:
+  - id: contest-reading
+    title: 比赛读题与筛选
+    contestUse: 在前 30 分钟扫完题面，识别可做题和高风险题，避免漏读与过早开写。
+    nodes: []
+    appliesTo: [所有区域赛场次]
+    extensions: [首轮扫描, 题目分层, 读题时间盒]
+    notFor: [把 A 题默认当成签到题, 读一题写一题]
+    commonFailures: [漏读题面, 被样例带偏, 没有放弃条件]
+    transferProblems: [一场完整 VP]
+    exitEvidence: [两场 VP 都记录首轮扫描顺序, 没有漏读题]
+  - id: contest-decision
+    title: 比赛决策与终局
+    contestUse: 根据成功概率、剩余时间和罚时决定继续、换题或集中火力。
+    nodes: []
+    appliesTo: [区域赛 VP, 最后 60 分钟]
+    extensions: [换题阈值, 终局集中, 代码验算分工]
+    notFor: [多道难题同时无边界死磕]
+    commonFailures: [沉没成本, 最后阶段分散火力, 不复盘换题原因]
+    transferProblems: [5 小时团队 VP]
+    exitEvidence: [两场 VP 有明确换题记录和终局策略]
+  - id: implementation-stability
+    title: 实现稳定性
+    contestUse: 在限时下把已知套路写成一次通过、边界完整的代码。
+    nodes: [数据结构, 二分, 前缀和, 差分, 动态规划基础]
+    appliesTo: [中档签到题, 需要快速转化的常见模型]
+    extensions: [边界清单, 小样例自测, 重写压缩]
+    notFor: [只背模板不理解状态来源]
+    commonFailures: [下标错误, 初始化遗漏, 重复提交同一类低级错误]
+    transferProblems: [两道未见过的同类题]
+    exitEvidence: [两道迁移题限时独立通过, 至少一题隔天复测]
+  - id: dp-modeling
+    title: DP 建模与迁移
+    contestUse: 从题面抽出状态、转移、顺序和复杂度，而不是只认题型名称。
+    nodes: [动态规划基础, 区间 DP, 背包 DP, 树形 DP, 状压 DP, 数位 DP]
+    appliesTo: [子结构可复用, 状态规模可控, 需要枚举决策顺序]
+    extensions: [区间状态, 集合状态, 树上状态, 优化转移]
+    notFor: [状态包含不可压缩的全局历史]
+    commonFailures: [状态定义含糊, 转移漏情况, 复杂度算错]
+    transferProblems: [一道结构相同但题面不同的 DP, 一道隔天迁移题]
+    exitEvidence: [能解释状态为何足够, 两道新题独立完成]
+  - id: graph-modeling
+    title: 图论建模
+    contestUse: 识别图结构并选对最短路、连通性、拓扑序、树或网络流模型。
+    nodes: [图论基础, 最短路, 拓扑排序, DFS（搜索）, 并查集]
+    appliesTo: [关系传播, 依赖顺序, 连通块, 路径代价]
+    extensions: [DAG DP, 树上问题, 生成树, 流与匹配]
+    notFor: [把所有关系题都硬套最短路]
+    commonFailures: [建边方向错, 忘记不连通, 复杂度超限]
+    transferProblems: [两种表面不同的关系建模题]
+    exitEvidence: [限时识别模型并独立写出两题]
+  - id: data-structures
+    title: 数据结构选型与实现
+    contestUse: 根据操作、约束和查询方式选择合适结构并稳定实现。
+    nodes: [树状数组, 线段树, 单调队列, 单调栈, 树链剖分]
+    appliesTo: [动态维护, 区间查询, 单调性优化]
+    extensions: [懒标记, 可持久化, 合并技巧, 复杂度降阶]
+    notFor: [数据结构复杂度超过题目实际需求]
+    commonFailures: [区间边界错, 懒标记下传错, 结构选重]
+    transferProblems: [同结构不同操作题]
+    exitEvidence: [模板能从零写出, 新题能说明为何选它]
+  - id: math-combinatorics
+    title: 数学与组合建模
+    contestUse: 把计数、模运算、概率和构造题压成可计算的结构。
+    nodes: [排列组合, 数论基础, 概率论, 博弈论]
+    appliesTo: [计数, 期望, 模意义运算, 不变量]
+    extensions: [容斥, 生成函数, 矩阵快速幂, 组合恒等式]
+    notFor: [只凭样例猜规律]
+    commonFailures: [重复计数, 模逆不存在, 边界概率遗漏]
+    transferProblems: [两道不同叙事的计数题]
+    exitEvidence: [能写出计数对象和去重方式, 一题隔天复测]
+  - id: code-review
+    title: 代码检查与调试
+    contestUse: 在提交前快速发现边界、溢出、复杂度和实现偏差。
+    nodes: [枚举, 递归 & 分治, 动态规划基础]
+    appliesTo: [所有需要限时提交的题]
+    extensions: [反例构造, 对拍思维, 小样例清单]
+    notFor: [盲目重写整份代码]
+    commonFailures: [没有最小反例, 只看样例, 不验证复杂度]
+    transferProblems: [给出一份错误代码并定位最小反例]
+    exitEvidence: [三次提交前检查都能指出具体风险]
+  - id: team-communication
+    title: 团队沟通与分工
+    contestUse: 让三个人并行推进、及时同步、减少重复劳动和信息丢失。
+    nodes: []
+    appliesTo: [团队 VP, 区域赛现场]
+    extensions: [口头题解格式, 代码交接, 验算角色, 决策记录]
+    notFor: [三个人长期各做各的]
+    commonFailures: [没人汇报, 两人重复做题, 交接时丢约束]
+    transferProblems: [三人 5 小时 VP]
+    exitEvidence: [两场 VP 有分工记录和交接记录]

package/assets/rules/coach-rules.md

@@ -7,6 +7,20 @@
 
 ## 教练职责（核心）
 
+### 比赛目标先于知识图
+
+* 有比赛目标时，先调 `coach_target read`，再调 `coach_focus`。没有目标时不能用
+  rating、游标或地图后继猜长期方向；先建立比赛、日期、结果目标、团队模式、时间预算
+  和能力优先级。
+* `coach_focus` 给的是比赛能力重点，不是知识点清单。每次训练必须说明它服务哪个能力、
+  为什么现在排、暂缓什么，以及用什么表现退出。知识图只负责把能力重点展开成可学节点。
+* 有 VP 时先导入 `coach_vp_import`，赛后调 `coach_postmortem`。VP 的读题、耗时、提交、
+  换题和团队问题优先于 rating；没有 VP 证据时要明确说“尚无记录”，不能装作知道短板。
+* 讲知识点之前调 `coach_scope`。必须说明适用范围、延伸、反例、常见错误、迁移题和退出
+  条件；工具返回“没有范围卡片”时不许凭记忆补一段看似完整的范围。
+* 训练重点是比赛能力，不是沿着地图无限往下走。阶段达到目标后可以停在当前节点，转做
+  迁移题、限时题、VP 或复盘；后继节点只有在它服务当前能力目标时才进入。
+
 ### 长期课程先于每日选点
 
 * 长期训练先用 `coach_curriculum read` 查看路线，再用 `assess` 查实际编排依据。
@@ -51,7 +65,8 @@
 
 下面九条是硬规则，每条都能机械检查。违反就是没做好本职工作：
 
-1. **给训练指令前，必须先调 `coach_next`**。不许凭印象挑知识点 ——
+1. **给训练指令前，必须先调 `coach_target`/`coach_focus`，再调 `coach_next`**。
+   不许只凭 rating 或地图后继挑知识点 ——
    它可能在地图里根本不存在，或者前置还没满足。
 2. **每条指令必须带地图节点 id**。节点 id 只能从地图取到，
    所以这条会自动逼你先读地图。

package/dev/run-all.sh

@@ -8,6 +8,7 @@
 #   setup-check             冷启动（离线）
 #   curriculum-check        长期课程、版本、阶段验收与任务关联
 #   curriculum-evidence     编排证据目录、引用与事件身份
+#   strategy-check          比赛目标、VP 证据、复盘与重点选择
 #   parity-check            和线上那份的保真度对比
 #
 # 主验收跑的是**已安装副本**（不是源码）—— 那才是运行时真正加载的东西。
@@ -63,6 +64,7 @@ run "wiki-check"    node dev/wiki-check.mjs
 run "setup-check"   node dev/setup-check.mjs
 run "curriculum"    node --test dev/curriculum-check.mjs
 run "evidence"      node --test dev/curriculum-evidence-check.mjs
+run "strategy"      node --test dev/strategy-check.mjs
 if [ "${COACH_LIVE_INDEX+x}" = x ] || node -e "
   const fs=require('fs'), os=require('os'), path=require('path');
   process.exit(fs.existsSync(path.join(os.homedir(), '.dsh', 'profiles', 'web', 'node_modules', 'dsh-coach', 'index.js')) ? 0 : 1);

package/dev/strategy-check.mjs

@@ -0,0 +1,75 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtempSync, rmSync, existsSync } from 'node:fs'
+import { join } from 'node:path'
+import { createStrategyStore } from '../lib/strategy.js'
+
+function fixture() {
+  const dir = mkdtempSync(join(process.cwd(), '.strategy-test-'))
+  const store = createStrategyStore({
+    dataDir: dir,
+    competenciesPath: join(process.cwd(), 'assets', 'knowledge', 'COMPETENCIES.yaml'),
+  })
+  return { dir, store }
+}
+
+test('target is explicit and revision protected', () => {
+  const { dir, store } = fixture()
+  try {
+    assert.equal(store.target('read').revision, 0)
+    const saved = store.target('set', {
+      expectedRevision: 0, contest: '西安区域赛', date: '2026-10-18', result: '区域赛金牌',
+      teamMode: 'team', weeklyHours: 35,
+      constraints: { weekday: 5, saturday: 10, sunday: 0 },
+      priorities: [{ id: 'contest-reading', weight: 100, reason: '区域赛前要先稳定读题' }],
+    })
+    assert.equal(saved.ok, true)
+    assert.equal(saved.revision, 1)
+    assert.equal(store.target('set', { expectedRevision: 0 }).ok, false)
+    assert.equal(existsSync(join(dir, 'TARGET.yaml')), true)
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
+test('VP import is idempotent and postmortem drives focus', () => {
+  const { dir, store } = fixture()
+  try {
+    store.target('set', {
+      expectedRevision: 0, contest: '西安区域赛', date: '2026-10-18', result: '区域赛金牌',
+      teamMode: 'team', weeklyHours: 35,
+      priorities: [
+        { id: 'contest-reading', weight: 80 },
+        { id: 'dp-modeling', weight: 70 },
+      ],
+    })
+    const event = { eventId: 'vp-1', contest: '训练 VP', date: '2026-10-10', durationMinutes: 300,
+      problems: [{ problemId: 'A', status: 'AC', solveMinutes: 20, competencies: ['contest-reading'] }] }
+    assert.equal(store.vpImport([event]).total, 1)
+    assert.equal(store.vpImport([event]).total, 1)
+    assert.equal(store.postmortem({ eventId: 'vp-1', competencies: ['contest-reading'], rootCauses: ['扫题不完整'], nextActions: ['固定首轮扫描'] }).ok, true)
+    const focus = store.focus()
+    assert.equal(focus.ok, true)
+    assert.equal(focus.focus[0].id, 'contest-reading')
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
+test('scope refuses unknown knowledge instead of inventing applicability', () => {
+  const { dir, store } = fixture()
+  try {
+    const v = store.scope('不存在的知识点')
+    assert.equal(v.ok, false)
+    assert.equal(v.found, false)
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})
+
+test('first-use focus has a complete refusal shape and targets reject unknown cards', () => {
+  const { dir, store } = fixture()
+  try {
+    const empty = store.focus()
+    assert.deepEqual(Object.keys(empty).sort(), ['contest', 'deadline', 'evidenceEvents', 'focus', 'ok', 'postmortems', 'postponed', 'reject'])
+    const rejected = store.target('set', {
+      expectedRevision: 0, contest: '西安区域赛', date: '2026-10-18', result: '区域赛金牌',
+      weeklyHours: 35, priorities: [{ id: 'invented-card', weight: 100 }],
+    })
+    assert.equal(rejected.ok, false)
+  } finally { rmSync(dir, { recursive: true, force: true }) }
+})

package/dev.sh

@@ -35,7 +35,7 @@ done
 # 从副本目录跑 `bash dev.sh` 走的是另一条路（`dsh plugin remove/add`，而那条
 # 路不可靠），和这份的行为不一样。换句话说，**同一个命令，从哪个目录按回车
 # 决定跑哪份脚本** —— 两份 dev.sh 就是两份真相，正是这份文件在防的那种坑。
-SYNC_FILES='index.js package.json verify.mjs verify-shape.mjs progress-cli.mjs build-node-meta.mjs cordis.patch.yml README.md lib/client.js lib/setup.js lib/curriculum.js lib/curriculum-evidence.js lib/curriculum-planning.js assets/rules/coach-rules.md dev/curriculum-check.mjs dev/curriculum-evidence-check.mjs docs/长期课程机制.md dev.sh'
+SYNC_FILES='index.js package.json verify.mjs verify-shape.mjs progress-cli.mjs build-node-meta.mjs cordis.patch.yml README.md lib/client.js lib/setup.js lib/curriculum.js lib/curriculum-evidence.js lib/curriculum-planning.js lib/strategy.js assets/knowledge/COMPETENCIES.yaml assets/rules/coach-rules.md dev/curriculum-check.mjs dev/curriculum-evidence-check.mjs dev/strategy-check.mjs docs/长期课程机制.md dev.sh'
 STALE=''
 for f in $SYNC_FILES; do
   for d in "${DSTS[@]}"; do

package/index.js

@@ -30,11 +30,12 @@ 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.0.0'
 
 // 块结构（方针 §4.1.1）：40 自己做 + 10 解决遗留 + 10 重写 = 60 分钟。
 // 这是**一个题目循环**的固定形状。时间不够该换更小的题，不是把块压扁。
@@ -71,6 +72,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'),
+})
 
 // 探针要的文件，各自代表一条后面的依赖：
 //   MAP.yaml      地图（coach_next 读它算候选）
@@ -1602,12 +1607,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 +1821,116 @@ 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 }, 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,
+        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 },
+    } }, render: (_a, v) => strategyText(v) },
+    execute: () => {
+      const v = strategy.focus()
+      return { ...v, 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}`),
+        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:

package/lib/strategy.js

@@ -0,0 +1,201 @@
+// 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 { join } from 'node:path'
+import { parse, stringify } from 'yaml'
+
+const clean = (value) => String(value ?? '').trim()
+const asArray = (value) => Array.isArray(value) ? value : []
+const isoDay = (value) => {
+  const day = clean(value)
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(day)) return ''
+  const d = new Date(`${day}T12:00:00Z`)
+  return Number.isFinite(d.getTime()) && d.toISOString().slice(0, 10) === day ? day : ''
+}
+
+const emptyTarget = () => ({ version: 1, revision: 0, updated: '', contest: '', date: '', result: '', teamMode: 'solo', weeklyHours: 0, constraints: {}, priorities: [] })
+const emptyVp = () => ({ version: 1, revision: 0, updated: '', events: [], postmortems: [] })
+
+function readYaml(path, fallback) {
+  try {
+    const value = parse(readFileSync(path, 'utf8'))
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : fallback()
+  } catch (err) {
+    if (err.code === 'ENOENT') return fallback()
+    throw err
+  }
+}
+
+function writeYaml(path, header, value) {
+  const tmp = `${path}.${process.pid}.${Date.now()}.tmp`
+  writeFileSync(tmp, header + stringify(value, { lineWidth: 0 }), 'utf8')
+  renameSync(tmp, path)
+}
+
+function normalizePriority(value) {
+  if (!value || typeof value !== 'object') return null
+  const id = clean(value.id || value.competency)
+  const weight = Number(value.weight)
+  if (!id || !Number.isFinite(weight) || weight <= 0) return null
+  return { id, weight: Math.min(100, Math.round(weight)), reason: clean(value.reason) }
+}
+
+function normalizeProblem(value) {
+  if (!value || typeof value !== 'object') return null
+  const problemId = clean(value.problemId || value.id)
+  if (!problemId) return null
+  const status = clean(value.status || value.verdict || 'unknown').toUpperCase()
+  return {
+    problemId,
+    status,
+    readMinutes: Math.max(0, Number(value.readMinutes) || 0),
+    solveMinutes: Math.max(0, Number(value.solveMinutes ?? value.elapsedMinutes) || 0),
+    attempts: Math.max(0, Math.trunc(Number(value.attempts) || 0)),
+    competencies: asArray(value.competencies || value.skills).map(clean).filter(Boolean).slice(0, 12),
+    note: clean(value.note),
+  }
+}
+
+function normalizeEvent(value) {
+  if (!value || typeof value !== 'object') return null
+  const eventId = clean(value.eventId || value.id)
+  const contest = clean(value.contest || value.contestId)
+  const date = isoDay(value.date || value.startedAt?.slice?.(0, 10))
+  const durationMinutes = Math.max(0, Math.trunc(Number(value.durationMinutes) || 0))
+  const problems = asArray(value.problems).map(normalizeProblem).filter(Boolean)
+  if (!eventId || !contest || !date || !problems.length) return null
+  return {
+    eventId, contest, date, durationMinutes,
+    virtual: value.virtual !== false,
+    teamMode: clean(value.teamMode || 'solo'),
+    problems,
+    note: clean(value.note),
+  }
+}
+
+function normalizePostmortem(value) {
+  if (!value || typeof value !== 'object') return null
+  const eventId = clean(value.eventId)
+  if (!eventId) return null
+  return {
+    eventId,
+    date: isoDay(value.date) || new Date().toISOString().slice(0, 10),
+    competencies: asArray(value.competencies).map(clean).filter(Boolean).slice(0, 12),
+    missedReads: asArray(value.missedReads).map(clean).filter(Boolean).slice(0, 20),
+    decisionErrors: asArray(value.decisionErrors).map(clean).filter(Boolean).slice(0, 20),
+    teamIssues: asArray(value.teamIssues).map(clean).filter(Boolean).slice(0, 20),
+    rootCauses: asArray(value.rootCauses).map(clean).filter(Boolean).slice(0, 20),
+    nextActions: asArray(value.nextActions).map(clean).filter(Boolean).slice(0, 20),
+    note: clean(value.note),
+  }
+}
+
+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 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()
+    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 }
+    if (action === 'clear') {
+      const next = { ...emptyTarget(), revision: old.revision + 1, updated: now().toISOString() }
+      saveTarget(next)
+      return { ok: true, reject: '', ...next }
+    }
+    const date = clean(args.date)
+    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)
+    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))
+    if (unknown.length) return { ok: false, reject: `能力优先级没有范围卡片：${unknown.join('、')}。先补充 COMPETENCIES.yaml。`, ...old }
+    const teamMode = clean(args.teamMode || old.teamMode || 'solo')
+    if (!['solo', 'team'].includes(teamMode)) return { ok: false, reject: 'teamMode 只能是 solo 或 team。', ...old }
+    const next = {
+      ...old, contest: clean(args.contest), date, result: clean(args.result),
+      teamMode, weeklyHours,
+      constraints: args.constraints && typeof args.constraints === 'object' ? args.constraints : old.constraints,
+      priorities, revision: old.revision + 1, updated: now().toISOString(),
+    }
+    saveTarget(next)
+    return { ok: true, reject: '', ...next }
+  }
+
+  function vpImport(events = []) {
+    const old = loadVp()
+    const normalized = events.map(normalizeEvent).filter(Boolean)
+    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 }
+  }
+
+  function postmortem(value) {
+    const eventId = clean(value?.eventId)
+    const vp = loadVp()
+    if (!vp.events.some((event) => event.eventId === eventId)) return { ok: false, reject: `找不到 VP「${eventId}」，先导入这场 VP。`, postmortems: vp.postmortems }
+    const record = normalizePostmortem(value)
+    if (!record || (!record.competencies.length && !record.rootCauses.length && !record.nextActions.length)) return { ok: false, reject: '复盘至少要写 competencies、rootCauses 或 nextActions 之一。', postmortems: vp.postmortems }
+    const list = vp.postmortems.filter((item) => item.eventId !== eventId)
+    list.push(record)
+    const next = { ...vp, postmortems: list, revision: vp.revision + 1, updated: now().toISOString() }
+    saveVp(next)
+    return { ok: true, reject: '', eventId, postmortems: next.postmortems, revision: next.revision }
+  }
+
+  function focus() {
+    const targetDoc = loadTarget()
+    const vp = loadVp()
+    const catalog = loadCompetencies()
+    if (!targetDoc.contest) return {
+      ok: false, reject: '还没有比赛目标，先用 coach_target set。', contest: '', deadline: '',
+      focus: [], postponed: [], evidenceEvents: vp.events.length, postmortems: vp.postmortems.length,
+    }
+    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 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 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 证据。') }
+    }).sort((a, b) => b.score - a.score)
+    return { ok: true, reject: '', contest: targetDoc.contest, deadline: targetDoc.date, focus: focus.slice(0, 3), postponed: focus.slice(3).map((item) => item.id), evidenceEvents: vp.events.length, postmortems: vp.postmortems.length }
+  }
+
+  function scope(nodeOrId) {
+    const catalog = loadCompetencies()
+    const direct = catalog.find((item) => item.id === nodeOrId || item.nodes?.includes(nodeOrId))
+    if (direct) return { ok: true, reject: '', found: true, ...direct }
+    return { ok: false, reject: `「${nodeOrId}」还没有范围卡片，不能凭空编造适用范围；先补充 COMPETENCIES.yaml。`, found: false, id: nodeOrId, title: nodeOrId, contestUse: '', nodes: [], appliesTo: [], extensions: [], notFor: [], commonFailures: [], transferProblems: [], exitEvidence: [] }
+  }
+
+  function context() {
+    const t = loadTarget()
+    if (!t.contest) return '- 比赛目标：尚未建立；先用 coach_target set，不要把 rating 当成长期目标。'
+    const f = focus()
+    return [
+      `- 比赛目标：${t.contest}，目标日期 ${t.date}，结果目标 ${t.result}，团队模式 ${t.teamMode}`,
+      `- 当前目标权重：${t.priorities.map((p) => `${p.id}(${p.weight})`).join('、')}`,
+      f.focus?.length ? `- 本轮优先能力：${f.focus.map((x) => `${x.title}（${x.whyNow}）`).join('；')}` : '- 当前没有可计算的能力重点。',
+      f.postponed?.length ? `- 暂缓能力：${f.postponed.join('、')}` : '',
+      '- 每次布置前先说明它服务哪个比赛能力、适用范围、迁移题和退出条件。',
+    ].filter(Boolean).join('\n')
+  }
+
+  return { target, vpImport, postmortem, focus, scope, context, loadTarget, loadVp, loadCompetencies }
+}
+
+export const normalizeVpEvent = normalizeEvent
+export const normalizeVpPostmortem = normalizePostmortem

package/package.json

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

package/verify-shape.mjs

@@ -167,6 +167,13 @@ const today = new Date().toLocaleDateString('sv-SE')   // YYYY-MM-DD（本地）
 // 每个工具至少两条路：走得通的 + 被拒的（**被拒的那条最容易形状不齐**）
 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: '测试目标' }] }],
+  ['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', {}],
+  ['coach_scope', { id: 'contest-reading' }],
+  ['coach_scope', { id: '不存在的能力' }],
   // 无课程的读取 / 无课程的推进拒绝，不建立课程以免改变后续旧工具夹具。
   ['coach_curriculum', { action: 'read' }],
   ['coach_curriculum', { action: 'assess' }],