acmer-coach 2.4.0 → 2.6.0

package/index.js

@@ -1,7 +1,7 @@
 // acmer-coach
 // ══════════════════════════════════════════════════════════════════
-// 小鲸教练插件。目标：把「位置 + 判断」从小鲸的转述里拿回来 ——
-// 给它唯一动作、让它读代码判因、按检测推进，而不是报一堆百分比。
+// 小鲸教练插件。目标：保存训练位置与可核查的证据，
+// 让教练据此决定讲法、练习和复习，避免跨会话丢进度。
 //
 // 注册走 bundle 层：package.json 声明 `dsh.bundle.patch`，由
 // cordis.patch.yml 里那行 insert 挂上去。
@@ -31,26 +31,27 @@ import { defineTool } from '@deepseek-ai/dsh-tools'
 import { initDataDir, syncCodeforces, contactEvidence, importPool, importRecords } from './lib/setup.js'
 import { createCurriculumStore, curriculumTool } from './lib/curriculum.js'
 import { createStrategyStore } from './lib/strategy.js'
+import { createTeachingNotes } from './lib/teaching.js'
 import { createVpClient } from './lib/vp-client.js'
 import { migratePersonalWorkspace as migrateWorkspacePersonalFiles } from './lib/workspace-migration.js'
 
 const name = 'acmer-coach'
 const inject = ['tools']
 
-const VERSION = '2.4.0'
+const VERSION = '2.6.0'
 
-// 块结构（方针 §4.1.1）：40 自己做 + 10 解决遗留 + 10 重写 = 60 分钟。
-// 这是**一个题目循环**的固定形状。时间不够该换更小的题，不是把块压扁。
+// 默认题目循环：40 自己做 + 10 解决遗留 + 10 重写 = 60 分钟。
+// 小诊断和完整 VP 使用独立时长，不强加题目循环的收尾。
 //
 // ⚠️ **单位统一（需求 #7）**：系统里说「40 分钟」，一律指
 // **他自己动手做题的净时间** —— 止损点就是它。收尾那 20 分钟（遗留 10 +
 // 重写 10）**固定**、不随净时间压缩。
-//   净 40（默认）→ 整块 60；净 30（下限）→ 整块 50
+//   净 40（默认）→ 整块 60；显式小任务可缩短净时间
 // coach_assign 的参数曾经是"总时长"（工具内部减 20 才是自己做），而
 // coach_plan 的 cycle 和规则文件里的 40 都是"自己做" —— 同一个数两个意思，
 // 报时间线就会卡在这儿（传 40，实际只拿到 20 分钟自己做）。
 const NET_DEFAULT_MIN = 40        // 自己做：默认
-const NET_FLOOR_MIN = 30          // 自己做：下限。再短就该换更小的题，不是压扁循环
+const NET_FLOOR_MIN = 1           // 实际时间盒由教练按任务决定
 const TAIL_MIN = 20               // 解决遗留(10) + 重写(10)，不随净时间压缩
 const CYCLE_TOTAL_MIN = NET_DEFAULT_MIN + TAIL_MIN   // 60：题目循环的整块长度（plan 的 cycle 就是它）
 
@@ -83,6 +84,7 @@ function createStores(vpDir) {
   })
   curriculum = createCurriculumStore({
     dataDir: DATA_DIR, loadMap, loadProgress, loadSchedule,
+    loadCompetencies: () => strategy.loadCompetencies(),
     loadStrategyEvidence: () => strategy.evidence().evidence,
   })
 }
@@ -467,12 +469,13 @@ function setScheduleField(date, field, value) {
 // 而排程本身是**教学判断**（先补哪个点、排多密、今天要不要减量），
 // 那正是教练存在的理由，不该退回给训练员。
 //
-// 三种块（方针 §4.1.2）。**时长是常量，调用方不能传** ——
-// 传了就会冒出「排个 37 分钟的循环块」，而 40/10/10 的止损点全靠这个时长守着。
+// 块类型保留已有默认时长，允许教练按任务明确整块时长。
 const SCHED_KINDS = {
   cycle: { min: 60, name: '题目循环' },
   review: { min: 25, name: '复习一题' },
   exam: { min: 90, name: '章节检测' },
+  diagnostic: { min: 15, name: '短诊断' },
+  vp: { min: 300, name: '完整 VP' },
 }
 
 // 网格范围。⚠️ **必须和 skilltree_template.html 里的 HOUR_FROM / HOUR_TO 逐字一致**：
@@ -624,13 +627,18 @@ function planDay(date, blocks, opts = {}) {
       return
     }
     const node = String(b?.node ?? '').trim()
-    if (!byId.has(node)) {
-      const near = suggest(node, [...byId.values()])
-      errs.push(`${no}：地图里没有「${node}」这个知识点，别自己造。` +
-        (near.length ? `相近的有：${near.join(' / ')}` : '先用 coach_next 看他该学什么。'))
+    const competency = String(b?.competency ?? '').trim()
+    const identity = trainingIdentity(node, competency)
+    if (!identity.ok) {
+      errs.push(`${no}：${identity.reject}`)
       return
     }
-    out.push({ a, z: a + spec.min, kind, node, no })
+    const minutes = b?.minutes === undefined ? spec.min : b.minutes
+    if (!Number.isInteger(minutes) || minutes <= 0 || minutes > 960) {
+      errs.push(`${no}：minutes 必须是 1–960 的整数分钟。`)
+      return
+    }
+    out.push({ a, z: a + minutes, kind, node, competency, no })
   })
 
   // 排到网格外面的块，页面画不出来
@@ -671,6 +679,7 @@ function planDay(date, blocks, opts = {}) {
 
   const planned = sorted.map((b) => ({
     from: minHM(b.a), to: minHM(b.z), kind: b.kind, node: b.node,
+    ...(b.competency ? { competency: b.competency } : {}),
   }))
   const w = setScheduleField(d, 'planned', planned)
   if (!w.ok) return w
@@ -680,8 +689,9 @@ function planDay(date, blocks, opts = {}) {
     planned: sorted.map((b) => ({
       from: minHM(b.a), to: minHM(b.z), minutes: b.z - b.a,
       kind: b.kind, kindName: SCHED_KINDS[b.kind].name,
-      node: b.node, nodeName: byId.get(b.node)?.name ?? b.node,
-      domain: byId.get(b.node)?.domain ?? '',
+      node: b.node, nodeName: trainingIdentity(b.node, b.competency).name ?? b.node,
+      domain: trainingIdentity(b.node, b.competency).domain ?? '',
+      ...(b.competency ? { competency: b.competency } : {}),
     })),
     // 只报「这天一共排了多少分钟」这个**事实**（他排完之后自己看表用）。
     planMin,
@@ -756,11 +766,12 @@ function unplanDay(date, opts = {}) {
   if (!w.ok) return w
 
   const { byId } = loadMap()
-  const nameOf = (b) => byId.get(String(b?.node ?? ''))?.name ?? String(b?.node ?? '')
+  const nameOf = (b) => trainingIdentity(String(b?.node ?? ''), String(b?.competency ?? '')).name ?? String(b?.node ?? '')
   const pack = (b) => ({
     from: String(b?.from ?? ''), to: String(b?.to ?? ''),
     kind: String(b?.kind ?? ''), kindName: SCHED_KINDS[b?.kind]?.name ?? String(b?.kind ?? ''),
     node: String(b?.node ?? ''), nodeName: nameOf(b),
+    ...(b?.competency ? { competency: String(b.competency) } : {}),
   })
   return {
     ok: true, reject: '', date: d,
@@ -847,7 +858,8 @@ function scheduleOverview(days = SCHED_WINDOW, fromDate = '') {
         kind: String(b?.kind ?? ''),
         kindName: SCHED_KINDS[b?.kind]?.name ?? String(b?.kind ?? ''),
         node: String(b?.node ?? ''),
-        nodeName: byId.get(String(b?.node ?? ''))?.name ?? String(b?.node ?? ''),
+        nodeName: trainingIdentity(String(b?.node ?? ''), String(b?.competency ?? '')).name ?? String(b?.node ?? ''),
+        ...(b?.competency ? { competency: String(b.competency) } : {}),
       }
     })
     const planMin = planned.reduce((t, b) => t + b.minutes, 0)
@@ -876,12 +888,13 @@ function scheduleOverview(days = SCHED_WINDOW, fromDate = '') {
         const e = {
           node: nodeId,
           plannedMin: planned
-            .filter((b) => String(b.node) === nodeId)
+            .filter((b) => a?.competency ? b.competency === a.competency : String(b.node) === nodeId && !b.competency)
             .reduce((t, b) => t + Number(b.minutes ?? 0), 0),
           actualMin: Number(a?.actualMin ?? 0),
           solved: a?.solved === true,
           independent: a?.independent === true,
         }
+        if (a?.competency) e.competency = String(a.competency)
         if (a?.note) e.note = String(a.note)
         return e
       }),
@@ -906,6 +919,13 @@ function resolveCursor(explicit) {
   return s || loadProgress().cursor
 }
 
+function trainingIdentity(node, competency) {
+  if (Boolean(node) === Boolean(competency)) return { ok: false, reject: 'node 与 competency 必须且只能指定一个。' }
+  const entry = competency ? strategy.loadCompetencies().find(item => item.id === competency) : loadMap().byId.get(node)
+  if (!entry) return { ok: false, reject: competency ? `能力目录中没有「${competency}」。` : `地图里没有「${node}」这个知识点，别自己造。先调 coach_next 看候选。` }
+  return { ok: true, key: node || `competency:${competency}`, name: entry.name ?? entry.title ?? node, domain: entry.domain ?? (competency ? '比赛能力' : '') }
+}
+
 // 状态读取。**缺省即未学** —— 只有非未学的节点才会被写进文件。
 function nodeStatus(progress, id) {
   const s = progress?.nodes?.[id]?.status
@@ -993,7 +1013,7 @@ function nodeFlags(progress, byId) {
 // 判据 = 进度文件里**有没有关于这个节点的记录**。缺省即未学（见 nodeStatus：
 // 只有非未学的节点才会被写进文件），所以"记录存在"本身就说明有东西发生过：
 //   · `rec.at`   —— 教练标过「在学」的那天（见 markStatus：只在状态真变时更新）
-//   · `taught`   —— 布置过讲授段的那天（coach_assign 带 teachMinutes）
+//   · `taught`   —— 旧版讲解计划留下的日期，保留兼容，不证明实际讲过
 //   · `passes`   —— 他打过卡（coach_log）
 //   · `checks`   —— 判过一次卷（coach_grade）
 //
@@ -1008,9 +1028,7 @@ function taughtEvidence(progress, id) {
   if (!rec) return null
   const dates = [
     String(rec.at ?? ''),
-    // 讲授段的落点：在这之前，讲过的节点**不留任何痕迹** ——
-    // coach_status 会一直报「还没有教学记录」，而"游标节点豁免先讲闸门"这条
-    // 也就永远没法按"讲过没"来判断（这个漏洞就是从这儿反推出来的）。
+    // 兼容旧版接触线索；新计划不再写 taught，续课笔记也不算掌握证据。
     ...(Array.isArray(rec.taught) ? rec.taught.map((t) => String(t ?? '')) : []),
     ...(Array.isArray(rec.passes) ? rec.passes.map((p) => String(p?.date ?? '')) : []),
     ...(Array.isArray(rec.checks) ? rec.checks.map((c) => String(c?.date ?? '')) : []),
@@ -1670,7 +1688,7 @@ function registerPages(ctx) {
 // 它要防的是"规则被长对话压掉"，而规则在 AGENTS.md 里 —— 那是 system prompt，
 // 压根不参与压缩。真正会丢的是**位置**，而 pre-step 每轮都重注一遍，
 // 压掉的下一轮就回来了。所以那半条是多余的。
-function registerStateHook(ctx) {
+function registerStateHook(ctx, teaching) {
   ctx.on('agent/pre-step', async ({ messages, step }, next) => {
     const decision = await next()
     try {
@@ -1684,13 +1702,14 @@ function registerStateHook(ctx) {
       const studying = Object.entries(p.nodes ?? {})
         .filter(([, r]) => r?.status === 'studying')
         .map(([id]) => id)
+      const teachingContext = teaching.context(p)
 
       // 课程可以先于游标存在；即使尚未布置动作，也要在新会话继续同一路线。
       let hasCurriculum = false
       try { hasCurriculum = Boolean(curriculum.load()) } catch { hasCurriculum = true }
       let hasTarget = false
       try { hasTarget = Boolean(strategy.loadTarget().contest) } catch { hasTarget = true }
-      if (!cursor && !pending && !studying.length && !hasCurriculum && !hasTarget) return decision
+      if (!cursor && !pending && !studying.length && !hasCurriculum && !hasTarget && !teachingContext) return decision
 
       const { byId } = loadMap()
       const nameOf = (id) => byId.get(String(id))?.name ?? String(id)
@@ -1698,6 +1717,7 @@ function registerStateHook(ctx) {
       const lines = ['<coach_state>', '（教练插件注入的位置，不用再调工具问）']
       lines.push(strategy.context())
       lines.push(curriculum.context())
+      if (teachingContext) lines.push(teachingContext)
       lines.push(cursor
         ? `- 游标：${nameOf(cursor)}（${cursor}）${node?.domain ? `　[${node.domain}]` : ''}`
         : '- 游标：**还没设** —— 先问清他现在在哪个知识点，用 coach_set_cursor 设上')
@@ -1951,6 +1971,43 @@ function apply(ctx) {
   } catch { /* 没这服务 / 没这文件 → 不注，照常加载 */ }
 
   ctx.tools.register(defineTool(curriculumTool(curriculum)))
+  const teaching = createTeachingNotes({ loadProgress, saveProgress, loadMap,
+    getSessionQuery: () => ctx.get?.('sessionQuery') })
+  ctx.tools.register(defineTool({
+    name: 'coach_note',
+    description: '读取或保存简短续课笔记：讲到哪里、教练的判断、下次怎样接着讲。复用节点进度账本；不改掌握状态或自动决定下一课。' +
+      'studentQuote 可选；提供时自动核对当前会话的学生原话，核对存在不代表已经理解。无回应依据时写明尚未核对，不编造表现。',
+    parameters: {
+      action: { type: 'string', enum: ['read', 'write'], description: '默认 read；write 追加一条笔记。' },
+      node: { type: 'string', description: '地图节点 id。写入默认游标；读取默认最近有笔记的未完动作，其次游标，无游标时读最近笔记。显式指定始终优先。' },
+      limit: { type: 'integer', description: '读取最近几条，默认 5，最多 20。' },
+      summary: { type: 'string', description: 'write 必填，实际讲授位置和教练判断，最多 1000 字；区分观察与推测。' },
+      nextStep: { type: 'string', description: 'write 必填，下次续课建议，最多 500 字；后续教练可据新表现调整。' },
+      studentQuote: { type: 'string', description: '可选，当前会话学生实际发过的一段原话，最多 1500 字；不需要手输消息 id。' },
+    },
+    output: { schema: { type: 'object', additionalProperties: false, properties: {
+      ok: { type: 'boolean', required: true }, reject: { type: 'string', required: true },
+      node: { type: 'string', required: true }, total: { type: 'integer', required: true },
+      notes: { type: 'array', required: true, items: { type: 'object', additionalProperties: false, properties: {
+        at: { type: 'string', required: true }, summary: { type: 'string', required: true }, nextStep: { type: 'string', required: true },
+        studentEvidence: { type: 'object', additionalProperties: false, properties: {
+          sessionId: { type: 'string', required: true }, seq: { type: 'integer', required: true },
+          messageId: { type: 'string', required: true }, quote: { type: 'string', required: true },
+        } },
+      } } },
+    } }, render: (_args, v) => [{ type: 'text', text: !v.ok ? `❌ ${v.reject}` : v.notes.length
+      ? `续课笔记 · ${v.node}（最近 ${v.notes.length} / 共 ${v.total} 条）\n` + v.notes.map(note =>
+        `${note.at}\n教练记录：${note.summary}\n续课建议：${note.nextStep}\n` +
+        (note.studentEvidence ? `学生原话：「${note.studentEvidence.quote}」（存在已核对，理解程度仍由教练判断）`
+          : '尚无学生回应依据；这条是教练笔记。')).join('\n\n')
+      : `「${v.node || '当前节点'}」尚无续课笔记。` }] },
+    execute: async (args = {}, exec) => {
+      const action = args.action ?? 'read'
+      if (action === 'read') return teaching.read(args)
+      if (action === 'write') return teaching.write(args, exec)
+      return { ok: false, reject: 'action 只能是 read 或 write。', node: '', notes: [], total: 0 }
+    },
+  }))
 
   // ── 目标驱动策略层：比赛目标 / VP 证据 / 复盘 / 当前重点 ─────────
   // 课程图回答“有哪些知识点”，策略层回答“为什么现在学这个”。两者分开，
@@ -2178,6 +2235,11 @@ function apply(ctx) {
       profile: { type: 'object', required: true, additionalProperties: false, properties: {
         id: { type: 'string', required: true }, title: { type: 'string', required: true }, scope: { type: 'string', required: true }, status: { type: 'string', required: true },
         sources: { type: 'array', required: true }, competencyIds: { type: 'array', required: true }, selectionGuidance: { type: 'array', required: true }, limitations: { type: 'array', required: true },
+        samples: { type: 'array', required: true },
+        coverage: { type: 'object', required: true, additionalProperties: false, properties: {
+          sampledProblems: { type: 'integer', required: true }, reviewedSolutions: { type: 'integer', required: true },
+          years: { type: 'array', required: true, items: { type: 'integer' } }, isSyllabus: { type: 'boolean', required: true },
+        } },
       } }, daysRemaining: { type: 'integer', required: true },
       course: { type: 'object', required: true, additionalProperties: false, properties: {
         exists: { type: 'boolean', required: true }, revision: { type: 'integer', required: true },
@@ -2205,7 +2267,7 @@ function apply(ctx) {
         focusExpired: Boolean(snapshot.focusExpired), missingFreshEvidence: snapshot.missingFreshEvidence ?? [],
       }
       return { ...v, course, text: v.ok ? [`【训练取舍依据】长期：${course.goal || '尚未建立'}\n本次：${v.contest} · ${v.deadline} · 剩余${v.daysRemaining}天`,
-        `样本：${v.profile.title || '未选择'}（${v.profile.status}）\n适用边界：${v.profile.limitations.join('；')}`,
+        `样本：${v.profile.title || '未选择'}（${v.profile.status}）\n覆盖：${v.profile.coverage.sampledProblems}题，${v.profile.coverage.reviewedSolutions}题已核对题解，年份 ${v.profile.coverage.years.join('、') || '无'}；不是完整考纲。\n适用边界：${v.profile.limitations.join('；')}`,
         ...v.focus.map((f, i) => `${i + 1}. ${f.title}（${f.id}）\n   比赛价值：${f.contestUse}\n   为什么现在：${f.whyNow}\n   关联知识点：${f.nodes.join('、') || '按比赛能力训练'}\n   近30天场次：确认短板${f.gapCount} / 独立起点${f.baselineCount} / 待确认${f.observationCount}`),
         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('、')}` : '',
@@ -2747,7 +2809,7 @@ function apply(ctx) {
               (v.suggestions.length ? `\n相近的有：${v.suggestions.join(' / ')}` : '\n也没找到相近的，确认一下写法。'),
           }]
         }
-        const TIER_TAG = { core: '★核心', normal: '常见', rare: '少见', skip: '不考' }
+        const TIER_TAG = { core: '★核心', normal: '常见', rare: '少见', skip: '默认暂缓' }
         // （需求 #4）：**每个节点都要出 entry**。
         // 原来是 `c.entry ? ' ≈'+c.entry : ''` —— 于是「没数据」和「够不着」
         // 在输出里长得一模一样（都是不显示），很容易把"没数据"读成
@@ -2979,41 +3041,40 @@ function apply(ctx) {
   //   ① node 必须在地图里   → 挡住它编知识点
   //   ② node 必须是游标的下一层 → 挡住它跳过前置乱指
   //   ③ 前置必须都满足       → 挡住「学这个之前你得先学那个」这类空头指令
-  //   ④ 时间盒不能短于 30 分钟 → 挡住排出没意义的表
+  //   ④ 时间盒必须是一天内的正整数分钟
   // 校验不过就**拒绝**，并把理由说清楚 —— 拒绝比给个错指令好。
   ctx.tools.register(defineTool({
     name: 'coach_assign',
     description:
       '布置**一个**训练动作。给训练员下指令时**必须**走这个工具，不要在正文里自由发挥 —— ' +
-      '它会把指令固定成「做什么 + 时间盒 + 交付物」，并校验你挑的知识点：' +
-      '必须存在于地图、必须是当前游标的下一层、前置必须都满足。校验不过会被拒绝并说明原因。' +
-      '它一次只收一个节点，所以**给不出候选列表** —— 这正是设计意图。' +
+      '它保存「做什么 + 时间盒 + 交付物」，支持地图节点或已有比赛能力：' +
+      '节点需符合游标或课程主线且前置满足；纯能力训练不要求游标。诊断和 VP 不强加做题收尾。' +
+      '它一次只收一个训练目标；时长由教练按任务决定。' +
       '有长期课程时先读 coach_curriculum，带 curriculumRevision；主线必须属于当前阶段，' +
       '补漏或复习用 purpose 与 routeReason 说明关系和回归条件。课程节点可以跨图分支，但前置检查仍生效。' +
-      '有比赛目标时，progress 动作还必须落在当前目标能力；跨重点训练只能走课程绑定，' +
+      '比赛目标与重点排序是决策参考，不会限制在排名前三；结合学生表现说明 why。' +
       '补漏/复习必须说明 routeReason。',
     parameters: {
       cursor: {
         type: 'string',
         description: '当前游标。不填就用 PROGRESS.yaml 里的（这是常态）。',
       },
-      node: { type: 'string', required: true, description: '地图知识点 id。无课程时从 coach_next 候选取；有课程时沿用当前主线，仍核查前置' },
+      node: { type: 'string', description: '地图知识点 id；与 competency 二选一。无课程时沿用游标，有课程时核查当前主线与前置。' },
+      competency: { type: 'string', description: '已有比赛能力 id，例如 contest-reading；纯能力训练不要求游标或虚构地图节点。与 node 二选一。' },
+      kind: { type: 'string', enum: ['practice', 'diagnostic', 'vp'], description: '默认 practice（保留做题与收尾）；diagnostic/vp 的 minutes 是整项时长，不强加收尾或讲课。' },
       deliverable: { type: 'string', required: true, description: '做完交什么，如「把代码贴给我」' },
       minutes: {
         type: 'number',
-        description:
-          `**他自己动手做题的净时间**（分钟）—— 止损点就是它，不是整块长度。` +
-          `默认 ${NET_DEFAULT_MIN}，最低 ${NET_FLOOR_MIN}。` +
-          `整块长度 = 净时间 + ${TAIL_MIN}（解决遗留 10 + 重写 10，固定不压缩）：` +
-          `净 ${NET_DEFAULT_MIN} → 整块 ${CYCLE_TOTAL_MIN}，和日程表上的 cycle 块对得上。`,
+        description: '1–960 的整数分钟。地图 practice 是自己动手的净时间（默认40，另加20收尾）；diagnostic/vp或纯能力动作是整项时长。',
       },
       teachMinutes: {
         type: 'number',
         description:
-          '**先讲一遍**的时间（分钟）。开一个他从没碰过的知识点时**必须给**，' +
+          'practice 开全新地图知识点时先讲的时间（分钟）；diagnostic/vp 不要求讲解。' +
           '不给会被拒绝 —— 直接扔题让他自己卡，那是给学过的人的练法。' +
           '讲多久**你自己定**（不参考任何固定值），看你判断他需要多少。' +
-          `最低 ${TEACH_FLOOR_MIN} 分钟，没有上限。已经在学或学过的节点不用给。`,
+          `给了讲解则最低 ${TEACH_FLOOR_MIN} 分钟，整项动作不得超过960分钟。已经在学或学过的节点不用给。` +
+          '这是计划时长，不能证明已经讲过或学生理解了。',
       },
       why: { type: 'string', description: '为什么挑它（一句话，进台账，供训练员质疑时举证）' },
       curriculumRevision: { type: 'integer', description: '有效课程 read 返回的 revision；无课程时可不填。' },
@@ -3030,6 +3091,7 @@ function apply(ctx) {
           cursor: { type: 'string', required: true },
           node: { type: 'string', required: true },
           nodeName: { type: 'string', required: true },
+          competency: { type: 'string' },
           domain: { type: 'string', required: true },
           // 需求 #7：minutes 是**净时间**（他自己做多久）；整块 = minutes + tailMinutes
           minutes: { type: 'integer', required: true },
@@ -3072,7 +3134,9 @@ function apply(ctx) {
           return [{
             type: 'text',
             text: `❌ 这条指令布置不了：${v.reject}\n\n` +
-              `**不要**改用候选列表交差 —— 先调 coach_next 重新挑一个就绪的，再调本工具。`,
+              (v.competency
+                ? '不要用候选列表代替指令；按拒绝原因核对能力、课程版本或时长，再调本工具。'
+                : `**不要**改用候选列表交差 —— 先调 coach_next 重新挑一个就绪的，再调本工具。`),
           }]
         }
         const table = v.blocks
@@ -3083,7 +3147,7 @@ function apply(ctx) {
           text: [
             `【今天这一个动作】${v.nodeName}　[${v.domain}]`,
             ``,
-            `做什么　${v.nodeName}（地图节点 ${v.node}）`,
+            `做什么　${v.nodeName}（${v.competency ? `比赛能力 ${v.competency}` : `地图节点 ${v.node}`}）`,
             // 需求 #7：两个数都印出来 ——「同一个 40 两个意思」就是这条要治的病。
             `时间盒　自己做 ${v.minutes} + 收尾 ${v.tailMinutes} = 共 ${v.minutes + v.tailMinutes} 分钟` +
               (v.teachMinutes ? `（另有先讲 ${v.teachMinutes} 分钟，全场合计 ${v.totalMinutes}）` : ''),
@@ -3113,12 +3177,15 @@ function apply(ctx) {
       const { byId, dependents, stamp } = loadMap()
       const cursor = resolveCursor(args?.cursor)
       const node = String(args?.node ?? '').trim()
+      const competency = String(args?.competency ?? '').trim()
+      const identity = trainingIdentity(node, competency)
       const deliverable = String(args?.deliverable ?? '').trim()
+      const kind = String(args?.kind ?? 'practice').trim()
+      const tail = kind === 'practice' && !competency ? TAIL_MIN : 0
       let why = String(args?.why ?? '').trim()
       // 需求 #7：这个数现在是**净时间**（他自己动手做多久），不是整块长度。
       // 整块 = 净 + TAIL_MIN（收尾固定 20），下面 blocks 和 totalMinutes 都照这个算。
-      const net = Number.isFinite(args?.minutes)
-        ? Math.trunc(args.minutes) : NET_DEFAULT_MIN
+      const net = args?.minutes === undefined ? NET_DEFAULT_MIN : args.minutes
 
       // 校验失败一律走这里：回一个带原因的空壳，**不抛异常** ——
       // 抛异常会让对话断在那里，而拒绝是要让模型看见理由并改选的。
@@ -3126,7 +3193,7 @@ function apply(ctx) {
         accepted: false, reject,
         cursor, node, nodeName: byId.get(node)?.name ?? '',
         domain: byId.get(node)?.domain ?? '',
-        minutes: net, teachMinutes: 0, tailMinutes: TAIL_MIN, totalMinutes: 0, boxNote: '',
+        minutes: Number.isInteger(net) ? net : 0, teachMinutes: 0, tailMinutes: tail, totalMinutes: 0, boxNote: '',
         deliverable, why, mapStamp: stamp, blocks: [], selfTarget: false,
         // 需求 #6：拒绝时也把这两个字段摆出来 —— 白名单式的 schema
         // （additionalProperties: false + required:true）要求每个出口同形，
@@ -3135,15 +3202,16 @@ function apply(ctx) {
       })
 
       // ① 游标认不认得。「没设」和「打错」分开提示，别让模型去猜。
-      if (!cursor) {
+      if (!identity.ok) return deny(identity.reject)
+      if (!competency && !cursor) {
         return deny('还没设游标（PROGRESS.yaml 里 cursor 是空的）。' +
           '先确认训练员现在在哪个知识点，用 coach_set_cursor 设上。')
       }
-      if (!byId.has(cursor)) {
+      if (!competency && !byId.has(cursor)) {
         return deny(`地图里没有游标「${cursor}」。`)
       }
       // ② 节点必须真实存在 —— 挡住编造知识点
-      if (!byId.has(node)) {
+      if (!competency && !byId.has(node)) {
         const near = suggest(node, [...byId.values()])
         return deny(
           `地图里没有「${node}」这个知识点，别自己造。` +
@@ -3151,7 +3219,7 @@ function apply(ctx) {
       }
       let route
       try {
-        route = curriculum.assignment({ node, revision: args?.curriculumRevision,
+        route = curriculum.assignment({ node, competency, revision: args?.curriculumRevision,
           purpose: args?.purpose, reason: args?.routeReason })
       } catch (err) { return deny(`课程读取失败：${err.message}；先核查，不凭印象布置。`) }
       if (!route.ok) return deny(route.reject)
@@ -3160,10 +3228,12 @@ 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) })
+      const targetRoute = competency
+        ? { ok: true, targetAligned: strategy.loadTarget().priorities.some(item => item.id === competency), competencyIds: [competency] }
+        : 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 || '当前重点对应的训练动作'}`
+        why = `目标能力「${targetRoute.competencyIds.join('、')}」：${why || '目标能力对应的训练动作'}`
       }
 
       // ③ 未建课程时沿用直接后继；有课程时允许当前阶段跨分支，仍检查前置。
@@ -3175,12 +3245,12 @@ function apply(ctx) {
       // 教练就一个动作都给不出来了 —— 它只能眼睁睁看着人卡住。
       //
       // 已经 verified 的不许再指回来：学完了就该往前走。
-      if (node === cursor) {
+      if (!competency && node === cursor) {
         if (nodeStatus(loadProgress(), cursor) === 'verified' && route.binding?.purpose !== 'review') {
           return deny(`「${cursor}」已经验证过了 —— 学完了就往前走，` +
             '别在验证过的地方打转。用 coach_next 看下一层，或者往前沿退。')
         }
-      } else if (!(dependents.get(cursor) ?? []).includes(node) && !route.binding) {
+      } else if (!competency && !(dependents.get(cursor) ?? []).includes(node) && !route.binding) {
         return deny(`「${node}」不是「${cursor}」的下一层。先调 coach_next 看它到底能开哪些。`)
       }
       // ④ 前置必须都满足 —— 挡住「你得先学那个」这类空头指令
@@ -3188,17 +3258,13 @@ function apply(ctx) {
       // 已学集合走**共用实现**：闭包(游标) ∪ 显式标为 学过/已验证 的节点。
       // 原先这里只展开游标自己，训练员标过的几十个节点全被当没看见。
       const assumed = assumedLearned(loadProgress(), byId, [cursor])
-      const missing = (byId.get(node).depends ?? []).filter((d) => !assumed.has(d))
+      const missing = (byId.get(node)?.depends ?? []).filter((d) => !assumed.has(d))
       if (missing.length) {
         return deny(`「${node}」还缺前置：${missing.join('、')}。它现在还开不了。`)
       }
       // ⑤ 时间盒下限（需求 #7：比的是**净时间**，不是整块长度）
-      if (net < NET_FLOOR_MIN) {
-        return deny(
-          `净时间 ${net} 分钟太短，一个题目循环压不到这个长度。` +
-          '时间不够应该换更小的题，或者改用 review 块（25 分钟），' +
-          `而不是把循环压扁。（下限：自己做 ${NET_FLOOR_MIN} 分钟 = 整块 ${NET_FLOOR_MIN + TAIL_MIN} 分钟）`)
-      }
+      if (!['practice', 'diagnostic', 'vp'].includes(kind)) return deny('kind 只能是 practice/diagnostic/vp。')
+      if (!Number.isInteger(net) || net < NET_FLOOR_MIN || net > 960) return deny('minutes 必须是 1–960 的整数分钟。')
       if (!deliverable) return deny('没写交付物。做完交什么必须说清楚，否则训练员不知道什么时候算完。')
 
       // ⑥ **开新知识点必须先讲**。
@@ -3221,11 +3287,13 @@ function apply(ctx) {
       // 而它存在的理由正是防「直接出题」。判据用 taughtEvidence，
       // 和 coach_test 开卷、coach_status 报「讲于哪」是同一个实现。
       const taughtBefore = taughtEvidence(loadProgress(), node) !== null
-      const isNewNode = nodeStatus(loadProgress(), node) === 'none' &&
+      const isNewNode = !competency && nodeStatus(loadProgress(), node) === 'none' &&
         !(node === cursor && taughtBefore)
       const teach = Number.isFinite(args?.teachMinutes) ? Math.trunc(args.teachMinutes) : 0
+      if (args?.teachMinutes !== undefined && (!Number.isInteger(args.teachMinutes) || args.teachMinutes < 0 || args.teachMinutes > 960)) return deny('teachMinutes 必须是 0–960 的整数分钟。')
+      if (net + tail + teach > 960) return deny('整项动作超过一天可训练的 960 分钟。')
 
-      if (isNewNode && teach <= 0) {
+      if (kind === 'practice' && isNewNode && teach <= 0) {
         return deny(`「${byId.get(node)?.name ?? node}」是**全新知识点**（图上没人碰过），` +
           '而你没给讲解段。\n' +
           '开新知识点要**先拿一道例题讲一遍**再出题 —— 直接扔题让他自己卡，' +
@@ -3234,23 +3302,19 @@ function apply(ctx) {
       }
       if (teach > 0 && teach < TEACH_FLOOR_MIN) {
         return deny(`讲解 ${teach} 分钟太短 —— 讲一道例题至少 ${TEACH_FLOOR_MIN} 分钟，` +
-          '再短就只是念一遍结论，等于没讲。讲多久你定，**没有上限**。')
+          '再短就只是念一遍结论，等于没讲。讲多久你定，整项时长需在一天内。')
       }
 
-      const n = byId.get(node)
+      const n = { name: identity.name, domain: identity.domain }
       const solve = net   // 需求 #7：净时间直接就是「自己做」那一段
 
       // 需求 #7 的两句提醒（只影响这段话，不挡布置）：
       //   · 压到默认以下 → 提醒它压的是**止损点**，不是块
       //   · 净 ≠ 默认 → 提醒它这个整块长度**表上排不出来**（别让两个工具再打架）
-      const squeeze = net < NET_DEFAULT_MIN
-        ? `净 ${net} 分钟低于默认的净 ${NET_DEFAULT_MIN} —— 你压的是止损点，不是块；时间不够请换更小的题。`
+      const shape = kind === 'practice' && net !== NET_DEFAULT_MIN
+        ? `净 ${net} → 整块 ${net + tail} 分钟，排程时带 minutes=${net + tail + teach}。`
         : ''
-      const shape = net !== NET_DEFAULT_MIN
-        ? `净 ${net} → 整块 ${net + TAIL_MIN} 分钟，**表上排不出这个形状**` +
-          `（表上只有 cycle ${CYCLE_TOTAL_MIN} / review 25 / exam 90）。`
-        : ''
-      const boxNote = [squeeze, shape].filter(Boolean).join(' ')
+      const boxNote = kind === 'practice' ? [shape].filter(Boolean).join(' ') : ''
 
       // ── 落盘：押上这个动作（需求 #6）─────────────────────
       // 布置的动作原先**只活在当次调用的返回里**：跨会话再开时教练不知道
@@ -3261,28 +3325,18 @@ function apply(ctx) {
       // 但要在输出里喊出来 —— 静默失败 = 下个会话重复布置。
       const progA = loadProgress()
       const pend = { ...(progA.pendingActions ?? {}) }
-      const replacedPending = Object.prototype.hasOwnProperty.call(pend, node)
+      const replacedPending = Object.prototype.hasOwnProperty.call(pend, identity.key)
       const assignedAt = ymdToday()
-      pend[node] = {
+      pend[identity.key] = {
         at: assignedAt, deliverable,
         // 存**拆开的**几个数，不存一个总数：总数在"整块 / 净时间"两种口径下
         // 含义不同，存总数等于把口径混进账本（那正是 #7 要治的病）。
-        solveMinutes: solve, tailMinutes: TAIL_MIN, teachMinutes: teach,
-        totalMinutes: net + teach + TAIL_MIN, why,
-      }
-      if (route.binding) pend[node].curriculum = route.binding
-      // 讲授段落盘：带 teachMinutes = 这次布置含讲授段，
-      // 在节点上记一条 `taught` 日期 —— 它是「讲过没」唯一的结构化痕迹。
-      // 在这之前讲完**不留任何记录**：coach_status 永远报「还没有教学记录」，
-      // 游标节点那条豁免也就没法按"讲过没"来判断（漏洞就是从这儿反推出来的）。
-      // 记的是"讲授段排上了"这一天，不是"讲得多好" —— 回答"讲过没"够用了。
-      if (teach > 0) {
-        const rec = { ...(progA.nodes[node] ?? {}) }
-        const taught = Array.isArray(rec.taught) ? rec.taught.slice() : []
-        if (!taught.includes(assignedAt)) taught.push(assignedAt)
-        rec.taught = taught
-        progA.nodes[node] = rec
+        solveMinutes: solve, tailMinutes: tail, teachMinutes: teach,
+        totalMinutes: net + teach + tail, why, kind,
+        ...(competency ? { competency } : {}),
       }
+      if (route.binding) pend[identity.key].curriculum = route.binding
+      // 布置讲解只保存计划；接触状态与理解证据由各自入口记录。
       progA.pendingActions = pend
       let pendingRecorded = true
       try { saveProgress(progA) } catch { pendingRecorded = false }
@@ -3290,8 +3344,9 @@ function apply(ctx) {
       return {
         accepted: true, reject: '',
         cursor, node, nodeName: n.name ?? node, domain: n.domain ?? '',
-        minutes: net, teachMinutes: teach, tailMinutes: TAIL_MIN,
-        totalMinutes: net + teach + TAIL_MIN, boxNote,
+        ...(competency ? { competency } : {}),
+        minutes: net, teachMinutes: teach, tailMinutes: tail,
+        totalMinutes: net + teach + tail, boxNote,
         deliverable, why, mapStamp: stamp, selfTarget: node === cursor,
         pendingRecorded, pendingReplaced: replacedPending,
         targetAligned: targetRoute.targetAligned, competencies: targetRoute.competencyIds,
@@ -3305,9 +3360,11 @@ function apply(ctx) {
               minutes: teach,
             }]
             : []),
-          { kind: 'solve', label: '自己做（限时，到点必须停）', minutes: solve },
-          { kind: 'resolve', label: '解决遗留（做出来了就复盘思路，没做出来就听讲）', minutes: 10 },
-          { kind: 'rewrite', label: '重写', minutes: 10 },
+          { kind: kind === 'practice' ? 'solve' : kind, label: kind === 'vp' ? '完整 VP（比赛过程与复盘另按交付物记录）' : kind === 'diagnostic' ? '诊断（限时观察当前表现）' : '自己做（限时，到点必须停）', minutes: solve },
+          ...(tail ? [
+            { kind: 'resolve', label: '解决遗留（做出来了就复盘思路，没做出来就听讲）', minutes: 10 },
+            { kind: 'rewrite', label: '重写', minutes: 10 },
+          ] : []),
         ],
       }
     },
@@ -3332,6 +3389,7 @@ function apply(ctx) {
           // 让"讲过没"对教练**可查** —— 判据跟 coach_test 开卷时用的同一个
           // 函数（taughtEvidence），不另写一份。需求 #5 的验收 ③。
           cursorTaught: { type: 'string', required: true },
+          teachingContext: { type: 'string', required: true },
           domain: { type: 'string', required: true },
           updated: { type: 'string', required: true },
           verifiedCount: { type: 'integer', required: true },
@@ -3384,6 +3442,7 @@ function apply(ctx) {
                 nodeName: { type: 'string', required: true },
                 date: { type: 'string', required: true },
                 outcome: { type: 'string', required: true },
+                independent: { type: 'boolean' },
                 score: { type: 'integer', required: true },
                 maxScore: { type: 'integer', required: true },
                 minutes: { type: 'integer', required: true },
@@ -3468,6 +3527,8 @@ function apply(ctx) {
                 node: { type: 'string', required: true },
                 nodeName: { type: 'string', required: true },
                 at: { type: 'string', required: true },
+                competency: { type: 'string' },
+                kind: { type: 'string' },
                 // 押了几天。-1 = 日期不明（跟火候那边同一个约定，别让它算成 0）
                 days: { type: 'integer', required: true },
                 deliverable: { type: 'string', required: true },
@@ -3489,9 +3550,10 @@ function apply(ctx) {
             // 十有八九就是游标这个节点。埋在别处等于没报。（需求 #5 验收 ③）
             (v.cursorName
               ? (v.cursorTaught
-                ? `　讲于 ${v.cursorTaught}`
+                ? `　接触记录 ${v.cursorTaught}（不证明理解）`
                 : `　⚠️ **还没有教学记录** —— 现在开卷会被拒，先讲`)
               : ''),
+          v.teachingContext,
           // 押着的卷放最前面之一：它是个**卡住下一步的约束**（有新卷就开不了），
           // 埋在底下等于没报。
           v.pendingNode
@@ -3504,7 +3566,7 @@ function apply(ctx) {
           v.pendingActions.length
             ? '📌 **押着的动作**（布置了、还没落地）：\n' +
               v.pendingActions.map((a) =>
-                `　· ${a.nodeName}${a.nodeName !== a.node ? `（${a.node}）` : ''}　` +
+                `　· ${a.nodeName}${a.node && a.nodeName !== a.node ? `（${a.node}）` : ''}　` +
                 `交付物 ${a.deliverable}　` +
                 `时间盒 自己做 ${a.solveMinutes} + 收尾 ${a.tailMinutes} = ${a.solveMinutes + a.tailMinutes} 分钟` +
                 (a.teachMinutes ? `，另加先讲 ${a.teachMinutes}（共 ${a.totalMinutes}）` : '') +
@@ -3533,6 +3595,7 @@ function apply(ctx) {
           v.checkTotal
             ? `检测记录 ${v.checkTotal} 次，最近：` + v.recentChecks.slice(0, 4).map((c) =>
               `${c.date.slice(5)} ${c.nodeName} ${OUTCOME_TAG[c.outcome] ?? c.outcome}` +
+              (c.outcome === 'passed' ? (c.independent === true ? '［独立］' : c.independent === false ? '［有帮助］' : '［独立性未知］') : '') +
               (c.outcome === 'overTime' ? `（${c.minutes}/${c.limit} 分钟）` : '') +
               (c.verifiedAt ? ` 验证于≈${c.verifiedAt}` : '') +
               (c.selfReported ? `［含 ${c.selfReported} 道自述题］` : '')).join('　·　')
@@ -3579,6 +3642,7 @@ function apply(ctx) {
           allChecks.push({
             node: id, nodeName: name,
             date: String(c?.date ?? ''), outcome: String(c?.outcome ?? ''),
+            ...(typeof c?.independent === 'boolean' ? { independent: c.independent } : {}),
             score: Number(c?.score ?? 0), maxScore: Number(c?.maxScore ?? 0),
             minutes: Number(c?.minutes ?? 0), limit: Number(c?.limit ?? 0),
             verifiedAt: Number(c?.verifiedAt ?? 0),
@@ -3640,6 +3704,7 @@ function apply(ctx) {
         cursor: p.cursor,
         cursorName: byId.get(p.cursor)?.name ?? '',
         cursorTaught: taughtEvidence(p, p.cursor)?.first ?? '',
+        teachingContext: teaching.context(p),
         domain: byId.get(p.cursor)?.domain ?? '',
         updated: p.updated,
         verifiedCount: verified.length,
@@ -3673,7 +3738,9 @@ function apply(ctx) {
           const then = parseYmd(at)
           const days = then ? Math.round((parseYmd(ymdToday()) - then) / 86400000) : -1
           return {
-            node: id, nodeName: byId.get(id)?.name ?? id, at, days,
+            node: a?.competency ? '' : id,
+            nodeName: a?.competency ? strategy.loadCompetencies().find(card => card.id === a.competency)?.title ?? a.competency : byId.get(id)?.name ?? id,
+            ...(a?.competency ? { competency: String(a.competency), kind: String(a.kind ?? '') } : {}), at, days,
             deliverable: String(a?.deliverable ?? ''),
             solveMinutes: Number(a?.solveMinutes ?? 0),
             tailMinutes: Number(a?.tailMinutes ?? 0),
@@ -4925,25 +4992,19 @@ function apply(ctx) {
 
   // ── coach_grade：判卷 ────────────────────────────────────────
   //
-  // 检测闭环的收口。**「掌握」由检测决定，不由数据推断** —— 所以过了要写进
-  // verified：那是 verified 这一级的定义，不是顺手加的装饰。
-  //
-  // 三种结局**不能合并**：
-  //   passed   分够 + 没超时 → 真过了，标 verified，可以推进
-  //   overTime 分够 + 超时   → **不算过**。这是「不熟」的机械形态：
-  //                            方法他有，就是慢。去向是加练，不是推进。
-  //   failed   分不够         → 不过，交 coach_diagnose 判因
+  // 卷面通过与独立验证分开：分数、用时只证明本次过卷；独立性未知不补成 true。
+  // 历史 verified 不撤销，本次未独立验证也不刷新验证段位。
   //
   // 只依赖卷子本身（pending 里存了整份题目信息），不连数据库 ——
   // 判卷不该因为库被搬走或者锁了就失败。
   ctx.tools.register(defineTool({
     name: 'coach_grade',
     description:
-      '给正押着的那张检测卷判卷。他做完回来了，你收三样：每题 AC 没有、花了几分钟。\n' +
+      '给正押着的那张检测卷判卷。收每题 AC 与否、实际分钟数和明确的独立性事实（未知就省略）。\n' +
       '判定：难易加权（易1/中2/难3，满分 6），**通过线 4 分且总用时不超过限时**。\n' +
-      '分够但超时 → 判「不熟」不算过（方法有，就是慢）；分不够 → 不过。\n' +
-      '过了会自动把知识点标成「已验证」—— 那是 verified 的定义。\n' +
-      '判完给出下一步：过了就推进，不过就调 coach_diagnose 判因。',
+      '分够但超时 → overTime；分不够 → failed。卷面通过且所有做出的题明确独立，才产生本次 verified。\n' +
+      '接受过提示/题解/他人帮助，或独立性未知：只记过卷，保留原状态，不冒充独立掌握。\n' +
+      '本次独立验证不证明隔日保持或迁移；下一步由教练结合课程和表现判断。',
     parameters: {
       results: {
         type: 'array',
@@ -4956,6 +5017,7 @@ function apply(ctx) {
             problemId: { type: 'string', required: true, description: '卷子里的题号，原样抄' },
             solved: { type: 'boolean', required: true, description: '这题最后 AC 了吗' },
             minutes: { type: 'number', required: true, description: '这题花了多少分钟（没做出来就填实际耗掉的）' },
+            independent: { type: 'boolean', description: '这题是否未接受提示、题解或他人帮助而独立完成/尝试；未知就省略，不猜。' },
           },
         },
       },
@@ -4977,6 +5039,8 @@ function apply(ctx) {
           minutes: { type: 'integer', required: true },
           limit: { type: 'integer', required: true },
           status: { type: 'string', required: true },
+          verified: { type: 'boolean', required: true, description: '本次卷面通过且所有做出题都有明确独立事实；不代表长期保持或迁移。' },
+          independence: { type: 'string', required: true, description: '本次做出题的独立性：independent / assisted / unknown。' },
           verifiedAt: { type: 'integer', required: true },
           // 这张卷里有几道是「网上找的」（自述题）。>0 时这条 verified 的
           // 成色就要打折 —— 卷面上看得见，记录里也留痕。
@@ -4993,6 +5057,7 @@ function apply(ctx) {
                 cfRating: { type: 'integer', required: true },
                 solved: { type: 'boolean', required: true },
                 minutes: { type: 'integer', required: true },
+                independent: { type: 'boolean', description: '仅在本题明确报告独立性时返回。' },
                 // 网上找的题的 cfRating 是自报估值 —— 不计入 verifiedAt（见上面的
                 // solvedRatings 过滤）。来源得跟着结果走，不然判卷记录里分不出
                 // 这道题是库里查的还是他自己找的。**schema 得声明它** ——
@@ -5007,7 +5072,7 @@ function apply(ctx) {
       render: (_args, v) => {
         if (!v.ok) return [{ type: 'text', text: `❌ 判不了：${v.reject}` }]
         const head = v.outcome === 'passed'
-          ? `✅ 过了　${v.nodeName}`
+          ? `✅ 卷面通过${v.verified ? ' · 本次独立验证' : ' · 未形成独立验证'}　${v.nodeName}`
           : v.outcome === 'overTime'
             ? `⏱ 分数够，但超时了 —— 这不算过　${v.nodeName}`
             : `❌ 没过　${v.nodeName}`
@@ -5019,29 +5084,29 @@ function apply(ctx) {
           // 直接影响这条 verified 值不值钱，而"过了"这两个字会盖过一切。
           ...(v.selfReported
             ? [`⚠️ 其中 ${v.selfReported} 道是**网上找的**：题号没进过题库、难度是估的、` +
-               '「做出来了」也只有他这句话。它不算进验证段位 —— 这条 verified 的成色比真题卷低，' +
-               '想坐实这个知识点，下次用题库里的题再测一次。']
+               '做题结果是报告的事实，难度估值不计入验证段位；需要时用题库题再核对。']
             : []),
           '',
         ]
         for (const p of v.problems) {
           lines.push(`  ${p.solved ? '✓' : '✗'} ${p.band}　${p.problemId}　${p.title}　` +
-            `${p.minutes} 分钟（权重 ${p.weight}）`)
+            `${p.minutes} 分钟（权重 ${p.weight}；${p.independent === true ? '独立' : p.independent === false ? '有帮助' : '独立性未记录'}）`)
         }
         lines.push('', '── 下一步 ──')
         if (v.outcome === 'passed') {
-          lines.push(`  这一节标成「已验证」了 —— 验证于 ≈${v.verifiedAt} 段位。` +
-            '（等他 rating 涨上去，这个段位的题也会变难，到时候该复检）')
+          lines.push(v.verified
+            ? `  本次达到独立验证条件${v.verifiedAt ? `，题库难度上限≈${v.verifiedAt}` : '，没有可核对的题库难度段位'}；不代表隔日仍会或能迁移。`
+            : v.independence === 'assisted'
+              ? '  卷面过了，但做出题有帮助：保留原状态，不新增掌握证书；需要时再独立检测。'
+              : '  卷面过了，但独立性未记录：保留原状态，不新增掌握证书；不要把未知补成独立。')
           const course = curriculum.execute({ action: 'read' })
           lines.push(course.exists || !course.ok
             ? '  先读 coach_curriculum 检查当前阶段验收；单点过卷不会自动推进阶段。继续当前主线，整体成果达标后再 advance。'
-            : '  用 coach_assign 布置下一节 —— **推进，别回头**。')
+            : '  根据实际理解和独立表现，选择补练、复检、迁移或下一节。')
         } else if (v.outcome === 'overTime') {
-          lines.push('  他不是不会，是慢。别推进，也别当「不会」去补课 —— ' +
-            '换个同难度的题限时加练，把速度压进限时里。')
+          lines.push('  本次超过限时。结合做题过程判断是建模、实现还是速度问题，再决定补讲或限时加练。')
         } else {
-          lines.push('  让他把没做出来的那题代码贴过来，调 coach_diagnose 判因 —— ' +
-            '分清是「不会」还是「不认真」，再决定补课还是重写。')
+          lines.push('  结合没做出题的题面、代码和过程，用 coach_diagnose 判因，再决定补讲、练习或重写。')
         }
         return [{ type: 'text', text: lines.join('\n') }]
       },
@@ -5052,7 +5117,7 @@ function apply(ctx) {
       const deny = (reject) => ({
         ok: false, reject, node: '', nodeName: '', domain: '',
         outcome: '', score: 0, maxScore: 0, passScore: PASS_SCORE,
-        minutes: 0, limit: 0, status: '', verifiedAt: 0, problems: [], checks: 0,
+        minutes: 0, limit: 0, status: '', verified: false, independence: 'unknown', verifiedAt: 0, selfReported: 0, problems: [], checks: 0,
       })
 
       const prog = loadProgress()
@@ -5076,6 +5141,11 @@ function apply(ctx) {
       const keyOf = (id) => normId('nowcoder', String(id ?? '').trim())
       const byIdGiven = new Map()
       for (const r of given) {
+        if (!r || typeof r.problemId !== 'string' || !r.problemId.trim() || typeof r.solved !== 'boolean' ||
+            typeof r.minutes !== 'number' || !Number.isFinite(r.minutes) || r.minutes < 0 || !Number.isSafeInteger(Math.round(r.minutes)) ||
+            (r.independent !== undefined && typeof r.independent !== 'boolean')) {
+          return deny('每条结果必须有题号、布尔 solved 和非负有限分钟数；independent 只能是布尔值或省略。')
+        }
         const key = keyOf(r?.problemId)
         if (byIdGiven.has(key)) return deny(`题号 ${r.problemId} 报了两遍。`)
         byIdGiven.set(key, r)
@@ -5093,6 +5163,7 @@ function apply(ctx) {
         }
         const solved = r.solved === true
         const spent = Math.max(0, Math.round(Number(r.minutes) || 0))
+        if (!Number.isSafeInteger(minutes + spent)) return deny('总分钟数超出安全数值范围，不能记录。')
         if (solved) score += Number(q.weight) || 0
         minutes += spent
         graded.push({
@@ -5104,6 +5175,7 @@ function apply(ctx) {
           // 老卷子可能没有（那批 pending 是在加这个字段之前开的），兜底 0。
           cfRating: Math.round(Number(q.cfRating) || 0),
           solved, minutes: spent,
+          ...(typeof r.independent === 'boolean' ? { independent: r.independent } : {}),
         })
       }
 
@@ -5113,9 +5185,13 @@ function apply(ctx) {
       // 超时和分数不够是**两种病**：前者是不熟，后者是不会。
       const outcome = score < passScore ? 'failed'
         : (limit > 0 && minutes > limit) ? 'overTime' : 'passed'
+      const solvedProblems = graded.filter((g) => g.solved)
+      const independence = solvedProblems.some((g) => g.independent === false) ? 'assisted'
+        : solvedProblems.length && solvedProblems.every((g) => g.independent === true) ? 'independent' : 'unknown'
+      const verified = outcome === 'passed' && independence === 'independent'
 
       const node = String(p.node ?? '')
-      const status = outcome === 'passed' ? 'verified'
+      const status = verified ? 'verified'
         : nodeStatus(prog, node) === 'none' ? 'studying' : nodeStatus(prog, node)
 
       // 「验证于哪个段位」= 他拿下的题里 cfRating 最高的那个。
@@ -5130,7 +5206,7 @@ function apply(ctx) {
       const solvedRatings = graded
         .filter((g) => g.solved && g.source !== 'web')
         .map((g) => g.cfRating).filter((r) => r > 0)
-      const verifiedAt = outcome === 'passed' && solvedRatings.length
+      const verifiedAt = verified && solvedRatings.length
         ? Math.max(...solvedRatings) : 0
 
       // 自述题计数。
@@ -5149,10 +5225,10 @@ function apply(ctx) {
         date: localStamp(new Date()).slice(0, 10),
         outcome, score, maxScore, passScore,
         minutes, limit, verifiedAt, selfReported, problems: graded,
+        ...(independence === 'unknown' ? {} : { independent: independence === 'independent' }),
       })
       nodeRec.checks = checks
-      // 过 → verified（这是那一级的定义）。不过**不降级**已有的 learned/verified，
-      // 但若本来就没学过，标成「在学」—— 他显然正在这上面花时间。
+      // 未达到独立验证条件不降级旧状态；未学节点只记录正在学习。
       const prevStatus = nodeStatus(prog, node)
       nodeRec.status = status
       // ⚠️ 修过：这条路**以前没写 `at`**。
@@ -5171,7 +5247,7 @@ function apply(ctx) {
       return {
         ok: true, reject: '', node, nodeName: byId.get(node)?.name ?? node,
         domain: byId.get(node)?.domain ?? '', outcome, score, maxScore, passScore,
-        minutes, limit, status, verifiedAt, selfReported,
+        minutes, limit, status, verified, independence, verifiedAt, selfReported,
         problems: graded, checks: checks.length,
       }
     },
@@ -5323,6 +5399,7 @@ function apply(ctx) {
         type: 'string',
         description: '撤哪个节点的动作。不填 = 手上只有一条时撤那条；有多条会被拒绝并列出来。',
       },
+      competency: { type: 'string', description: '撤哪个比赛能力动作，与 node 二选一；都不填时手上只有一条可直接撤。' },
       reason: { type: 'string', description: '为什么撤（一句话，回显用）' },
     },
     output: {
@@ -5337,6 +5414,7 @@ function apply(ctx) {
           at: { type: 'string', required: true },
           deliverable: { type: 'string', required: true },
           reason: { type: 'string', required: true },
+          competency: { type: 'string' },
           remaining: { type: 'integer', required: true },
         },
       },
@@ -5362,6 +5440,13 @@ function apply(ctx) {
       const prog = loadProgress()
       const pend = { ...(prog.pendingActions ?? {}) }
       let node = String(args?.node ?? '').trim()
+      let competency = String(args?.competency ?? '').trim()
+      if (node && competency) return deny('node 与 competency 只能指定一个。')
+      if (competency) {
+        const identity = trainingIdentity('', competency)
+        if (!identity.ok) return deny(identity.reject)
+        node = identity.key
+      }
       if (!node) {
         const keys = Object.keys(pend)
         if (!keys.length) {
@@ -5378,6 +5463,7 @@ function apply(ctx) {
           '可能已经落地（coach_log 销的），或者被撤过了。')
       }
       const a = pend[node]
+      competency = String(a?.competency ?? '')
       delete pend[node]
       prog.pendingActions = pend
       try {
@@ -5386,7 +5472,9 @@ function apply(ctx) {
         return deny(`写盘失败：${err.message} —— 动作还押着，别当它撤了。`)
       }
       return {
-        ok: true, reject: '', node, nodeName: byId.get(node)?.name ?? node,
+        ok: true, reject: '', node: competency ? '' : node,
+        nodeName: trainingIdentity(competency ? '' : node, competency).name ?? node,
+        ...(competency ? { competency } : {}),
         at: String(a?.at ?? ''), deliverable: String(a?.deliverable ?? ''),
         reason, remaining: Object.keys(pend).length,
       }
@@ -5466,6 +5554,7 @@ function apply(ctx) {
                       kindName: { type: 'string', required: true },
                       node: { type: 'string', required: true },
                       nodeName: { type: 'string', required: true },
+                      competency: { type: 'string' },
                     },
                   },
                 },
@@ -5480,6 +5569,7 @@ function apply(ctx) {
                       actualMin: { type: 'integer', required: true },
                       solved: { type: 'boolean', required: true },
                       independent: { type: 'boolean', required: true },
+                      competency: { type: 'string' },
                       // 可选（coach_log 带 note 时才写）。不写 required —— 可选键
                       // 在 dsh 那套里就是"不写 required"，写 required:false 会抛。
                       note: { type: 'string' },
@@ -5593,10 +5683,8 @@ function apply(ctx) {
             L.push(`  ${r.nodeName}　${tag} ${ago}${rec}`)
           }
           L.push('',
-            '⚠️ **复习别把新知识挤没了。** 这套系统的价值在"往前推"，不在"原地保温" —— ' +
-            '一个月的表里全是复习，等于这个月没往前走。他自己会想先复习（复习舒服、' +
-            '做新题难受），**所以那个平衡得你来把**：复习块按上面的火候排，' +
-            '剩下的时间留给推进。')
+            '根据目标、剩余时间和实际表现，选择新课、复习、迁移或 VP。' +
+            '上面的间隔只供判断；不要为了填满课表持续开新知识点。')
         }
         L.push('', '要排就用 coach_plan，**一次只排他说的那一天**。')
         return [{ type: 'text', text: L.join('\n') }]
@@ -5625,8 +5713,8 @@ function apply(ctx) {
       '**范围只认他说的那一天**：他说「排今天」就只排今天，说「排周三」就只排周三，' +
       '不要顺手把明天后天一起铺了 —— 那是替他做决定，而且是没问过他的决定。\n' +
       '三种块：cycle = 题目循环 60min（40 自己做 + 10 解决遗留 + 10 重写）、' +
-      'review = 复习一题 25min、exam = 章节检测 90min。**时长不能改** —— ' +
-      '40 分钟那个止损点全靠它守着。\n' +
+      'review = 复习一题 25min、exam = 章节检测 90min；diagnostic 默认 15min、vp 默认 300min。' +
+      '这些是默认值；按任务需要用 minutes 明确时长。\n' +
       '工具只拦**物理上做不到的**：压着他标的忙事 / 块叠在一起 / 知识点不在图上 / ' +
       '日子在窗口外。**排多排少是你的判断，工具不给容量上限**，排太满的后果' +
       '让表里的' +
@@ -5637,13 +5725,15 @@ function apply(ctx) {
       date: { type: 'string', required: true, description: '哪天，YYYY-MM-DD，得在今天 ~ 今天+6 之间' },
       blocks: {
         type: 'array', required: true,
-        description: '要排的块，按时间先后给。结束时间由 kind 决定，不用你算',
+        description: '要排的块，按时间先后给。结束时间由 minutes 或 kind 默认时长决定',
         items: {
           type: 'object', additionalProperties: false,
           properties: {
             from: { type: 'string', required: true, description: '开始时间 "HH:MM"，要对齐 5 分钟' },
-            kind: { type: 'string', required: true, enum: ['cycle', 'review', 'exam'] },
-            node: { type: 'string', required: true, description: '知识点 id，必须在地图里' },
+            kind: { type: 'string', required: true, enum: ['cycle', 'review', 'exam', 'diagnostic', 'vp'] },
+            node: { type: 'string', description: '地图知识点 id；与 competency 二选一。' },
+            competency: { type: 'string', description: '已有比赛能力 id；与 node 二选一。' },
+            minutes: { type: 'integer', description: '整块时长 1–960 分钟；不填保留该 kind 的默认时长。' },
           },
         },
       },
@@ -5671,6 +5761,7 @@ function apply(ctx) {
                 node: { type: 'string', required: true },
                 nodeName: { type: 'string', required: true },
                 domain: { type: 'string', required: true },
+                competency: { type: 'string' },
               },
             },
           },
@@ -5700,7 +5791,7 @@ function apply(ctx) {
           (v.replaced ? `（覆盖掉原来那 ${v.replaced} 个块）` : '')]
         for (const b of v.planned) {
           L.push(`  ★ ${b.from}–${b.to}　${b.kindName}　${b.nodeName}` +
-            (b.kind === 'cycle' ? '　（40 自己做 → 10 解决遗留 → 10 重写）' : ''))
+            (b.kind === 'cycle' && b.minutes === CYCLE_TOTAL_MIN ? '　（40 自己做 → 10 解决遗留 → 10 重写）' : ''))
         }
         // 回一条**完整时间轴**，而不是「还剩多少分钟」。
         // 排完他得能一眼看出这块夹在哪两件事之间 —— 那个位置才决定来不来得及。
@@ -5722,6 +5813,8 @@ function apply(ctx) {
     async execute(args) {
       const blocks = (Array.isArray(args?.blocks) ? args.blocks : []).map((b) => ({
         from: String(b?.from ?? ''), kind: String(b?.kind ?? ''), node: String(b?.node ?? ''),
+        ...(b?.competency ? { competency: String(b.competency).trim() } : {}),
+        ...(b?.minutes !== undefined ? { minutes: b.minutes } : {}),
       }))
       const r = planDay(args?.date, blocks, { replace: args?.replace === true })
 
@@ -5795,6 +5888,7 @@ function apply(ctx) {
                 kindName: { type: 'string', required: true },
                 node: { type: 'string', required: true },
                 nodeName: { type: 'string', required: true },
+                competency: { type: 'string' },
               },
             },
           },
@@ -5809,6 +5903,7 @@ function apply(ctx) {
                 kindName: { type: 'string', required: true },
                 node: { type: 'string', required: true },
                 nodeName: { type: 'string', required: true },
+                competency: { type: 'string' },
               },
             },
           },
@@ -5879,7 +5974,7 @@ function apply(ctx) {
   ctx.tools.register(defineTool({
     name: 'coach_log',
     description:
-      '记一条**实际用时**：他做完一个块之后，报「做了多久、是不是独立做出来的」。\n' +
+      '记一条节点练习或比赛能力动作的**实际用时**：他做完一个块之后，报「做了多久、是不是独立做出来的」。\n' +
       '**每次他报告完成情况就调一次**（不管是做出来了还是没做出来、超时了还是提前），' +
       '这是系统学会"他真实速度是多少"的唯一来源 —— 不记，排程永远只能靠猜。\n' +
       '计划时长不用你填：那天表上排了多久，工具自己从 SCHEDULE.yaml 里算。\n' +
@@ -5888,7 +5983,8 @@ function apply(ctx) {
       '**同一天同一个知识点做了两道题，就调两次、各带自己的 problemId** —— ' +
       '别合成一条（合成之后「哪道独立做出来的」就没了，而那正是开不开检测卷的依据）。',
     parameters: {
-      node: { type: 'string', required: true, description: '知识点 id，必须在地图里' },
+      node: { type: 'string', description: '知识点 id；与 competency 二选一。' },
+      competency: { type: 'string', description: '已有比赛能力 id；记录能力诊断或完整 VP，与 node 二选一。' },
       // （需求 #2）：题号。**可选** —— 不填就是老行为（一天一节点一条）。
       problemId: {
         type: 'string',
@@ -5920,6 +6016,7 @@ function apply(ctx) {
           date: { type: 'string', required: true },
           node: { type: 'string', required: true },
           nodeName: { type: 'string', required: true },
+          competency: { type: 'string' },
           plannedMin: { type: 'integer', required: true },
           actualMin: { type: 'integer', required: true },
           deviation: { type: 'integer', required: true },
@@ -5963,7 +6060,7 @@ function apply(ctx) {
               ? `\n  （这天这个点${v.problemId ? '这道题' : ''}原来记过一条，覆盖了）`
               : '') +
             (v.recorded
-              ? `\n  台账：这个知识点第 ${v.passCount} 次做完记录。`
+              ? v.competency ? '\n  台账：比赛能力动作已记入实际记录；不证明长期掌握。' : `\n  台账：这个知识点第 ${v.passCount} 次做完记录。`
               : '\n  ⚠️ 掌握证据那条没写上（磁盘/权限问题）—— 时间记录是好的。') +
             (v.actionCleared
               ? '\n  📌 这个节点上押着的动作**销了** —— 这条记录就是它的落地。'
@@ -5980,6 +6077,8 @@ function apply(ctx) {
       const { byId } = loadMap()
       const node = String(args?.node ?? '').trim()
       const d = String(args?.date ?? '').trim() || ymdToday()
+      const competency = String(args?.competency ?? '').trim()
+      const identity = trainingIdentity(node, competency)
       const actualMin = Math.round(Number(args?.actualMin))
       const solved = args?.solved === true
       const independent = args?.independent === true
@@ -5996,7 +6095,8 @@ function apply(ctx) {
       if (!/^\d{4}-\d{2}-\d{2}$/.test(d)) {
         return deny(`日期要 YYYY-MM-DD 格式，收到「${d}」。`)
       }
-      if (!byId.has(node)) {
+      if (!identity.ok) return deny(identity.reject)
+      if (!competency && !byId.has(node)) {
         const near = suggest(node, [...byId.values()])
         return deny(`地图里没有「${node}」这个知识点，别自己造。` +
           (near.length ? `相近的有：${near.join(' / ')}` : '先调 coach_status 看他在哪。'))
@@ -6023,7 +6123,7 @@ function apply(ctx) {
         return a === null || z === null ? 0 : Math.max(0, z - a)
       }
       const plannedMin = (Array.isArray(day.planned) ? day.planned : [])
-        .filter((b) => String(b?.node ?? '') === node)
+        .filter((b) => competency ? b?.competency === competency : String(b?.node ?? '') === node && !b?.competency)
         .reduce((t, b) => t + blockMin(b), 0)
 
       // 同一天同一个点：**没给题号时**只留一条 —— 这张表没有开始时间，
@@ -6032,15 +6132,20 @@ function apply(ctx) {
       // （09-21 的 ST 表：P2880 独立 AC、1548B 带提示 AC），压成一条等于
       // 把"他独立做出过这个点的题"从台账里抹掉。
       const idx = list.findIndex((r) =>
-        String(r?.node ?? '') === node && String(r?.problemId ?? '') === problemId)
+        (competency ? r?.competency === competency : String(r?.node ?? '') === node && !r?.competency) && String(r?.problemId ?? '') === problemId)
       // 需求 #8：`plannedMin` 不再写进这条记录（见上面那段注释）
       const entry = { node, actualMin, solved, independent }
+      const pendingAction = loadProgress().pendingActions?.[identity.key]
+      if (competency) {
+        entry.competency = competency
+        entry.kind = pendingAction?.kind ?? 'diagnostic'
+      }
       if (problemId) entry.problemId = problemId
       if (note) entry.note = note
       const replaced = idx >= 0
       if (replaced) list[idx] = entry
       else list.push(entry)
-      const sameDayEntries = list.filter((r) => String(r?.node ?? '') === node).length
+      const sameDayEntries = list.filter((r) => competency ? r?.competency === competency : String(r?.node ?? '') === node && !r?.competency).length
 
       const w = setScheduleField(d, 'actual', list)
       if (!w.ok) return deny(w.reject)
@@ -6061,35 +6166,39 @@ function apply(ctx) {
       let passCount = 0
       try {
         const prog = loadProgress()
-        const rec = { ...(prog.nodes[node] ?? {}) }
-        const passes = Array.isArray(rec.passes) ? rec.passes.slice() : []
-        const e = { date: d, solved, independent, minutes: actualMin }
-        if (problemId) e.problemId = problemId
-        if (note) e.note = note
-        // 去重键和 SCHEDULE 那边**必须一致**（日期 + 节点 + 题号）：
-        // 两边口径分家的话，`coach_status` 的条目数和 `coach_next` 的计划
-        // 会对不上同一件事 —— 这个项目反复在治的就是这个病。
-        const pi = passes.findIndex((p) => String(p?.date ?? '') === d &&
-          String(p?.problemId ?? '') === problemId)
-        if (pi >= 0) passes[pi] = e
-        else passes.push(e)
-        rec.passes = passes
-        prog.nodes[node] = rec
+        if (!competency) {
+          const rec = { ...(prog.nodes[node] ?? {}) }
+          const passes = Array.isArray(rec.passes) ? rec.passes.slice() : []
+          const e = { date: d, solved, independent, minutes: actualMin }
+          if (problemId) e.problemId = problemId
+          if (note) e.note = note
+          // 去重键和 SCHEDULE 那边**必须一致**（日期 + 节点 + 题号）：
+          // 两边口径分家的话，`coach_status` 的条目数和 `coach_next` 的计划
+          // 会对不上同一件事 —— 这个项目反复在治的就是这个病。
+          const pi = passes.findIndex((p) => String(p?.date ?? '') === d &&
+            String(p?.problemId ?? '') === problemId)
+          if (pi >= 0) passes[pi] = e
+          else passes.push(e)
+          rec.passes = passes
+          prog.nodes[node] = rec
+          passCount = passes.length
+        }
         // 押着的动作**落地即销**（需求 #6）：这个节点上布置过、他这会儿记了
         // 一条做完记录 = 就是做了。撤销是 coach_unassign 的活（那条路不写 passes）——
         // 两个出口分开，是为了不让"做完了"和"不做了"在账上长成一个样。
-        if (prog.pendingActions && Object.prototype.hasOwnProperty.call(prog.pendingActions, node)) {
-          delete prog.pendingActions[node]
+        if (prog.pendingActions && Object.prototype.hasOwnProperty.call(prog.pendingActions, identity.key)) {
+          delete prog.pendingActions[identity.key]
           actionCleared = true
         }
         saveProgress(prog)
         recorded = true
-        passCount = passes.length
-      } catch { /* 落盘失败不影响时间那条已经写进去的记录 */ }
+        if (competency) passCount = sameDayEntries
+      } catch { actionCleared = false /* 日程已保存，进度未保存，动作仍在。 */ }
 
       return {
         ok: true, reject: '', date: d, node,
-        nodeName: byId.get(node)?.name ?? node,
+        nodeName: identity.name,
+        ...(competency ? { competency } : {}),
         plannedMin, actualMin, deviation: actualMin - plannedMin, solved, independent,
         replaced, problemId, sameDayEntries,
         totalLogged: list.length, recorded, actionCleared, passCount, updated: w.updated,
@@ -6097,8 +6206,8 @@ function apply(ctx) {
     },
   }))
 
-  // 强制力那一层（方针 §五 第四层）：每个 turn 注入当前位置
-  registerStateHook(ctx)
+  // 每个 turn 注入当前位置与续课线索，教学判断仍交给小鲸。
+  registerStateHook(ctx, teaching)
 
   // 技能树页面（可选注入 —— 没有 webServer 的环境跳过，工具照常工作）
   ctx.inject(['webServer'], (sctx) => { registerPages(sctx) })