acmer-coach 2.4.0 → 2.6.0

package/lib/curriculum-evidence.js

@@ -85,6 +85,7 @@ export function collectEvidence(progress, schedule = { days: {} }) {
     if (!seenIds.has(id)) {
       seenIds.add(id)
       const facts = {}
+      if (text(record.competency)) facts.competency = text(record.competency)
       if (typeof record.independent === 'boolean') facts.independent = record.independent
       if (record.occurredAt !== undefined) facts.occurredAt = record.occurredAt
       const minutes = source === 'schedule' ? record.actualMin : record.minutes
@@ -141,13 +142,16 @@ export function collectEvidence(progress, schedule = { days: {} }) {
     if (!day || !object(entry) || !Array.isArray(entry.actual)) continue
     for (const record of entry.actual) {
       const node = text(record?.node)
-      if (!node || !practiceValid(record, record?.actualMin)) continue
+      const competency = text(record?.competency)
+      if ((!node && !competency) || !practiceValid(record, record?.actualMin)) continue
       if (progressPractice.has(practiceKey(day, node, record, record.actualMin))) continue
       const signal = record.solved && record.independent ? 'baseline' : 'gap'
-      const label = record.solved ? (record.independent ? '独立做出' : '依赖提示或题解做出') : '尚未做出'
+      const label = competency && !node
+        ? (record.solved ? (record.independent ? '独立达到本次交付物要求' : '借助帮助达到本次交付物要求') : '尚未达到本次交付物要求')
+        : record.solved ? (record.independent ? '独立做出' : '依赖提示或题解做出') : '尚未做出'
       const summary = `${text(record.problemId) ? `${text(record.problemId)}：` : ''}${label}，实际用时 ${record.actualMin} 分钟`
       const locator = `${day}:${encodeURIComponent(text(record.problemId))}`
-      const eventId = `practice:${encodeURIComponent(node)}:${day}:${encodeURIComponent(text(record.problemId))}`
+      const eventId = `practice:${encodeURIComponent(node || `competency:${competency}`)}:${day}:${encodeURIComponent(text(record.problemId))}`
       add('schedule', node, day, locator, eventId, signal, summary, record)
     }
   }

package/lib/curriculum.js

@@ -17,10 +17,10 @@ function validDate(value) {
   const d = new Date(`${value}T12:00:00Z`)
   return Number.isFinite(d.getTime()) && d.toISOString().slice(0, 10) === value
 }
-export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSchedule = () => ({ days: {} }), loadStrategyEvidence = () => [], now = () => new Date() }) {
+export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSchedule = () => ({ days: {} }), loadCompetencies = () => [], loadStrategyEvidence = () => [], now = () => new Date() }) {
   const path = join(dataDir, 'CURRICULUM.yaml')
   const evidence = () => [
-    ...collectEvidence(loadProgress(), loadSchedule()).filter((entry) => loadMap().byId.has(entry.node)),
+    ...collectEvidence(loadProgress(), loadSchedule()).filter((entry) => loadMap().byId.has(entry.node) || loadCompetencies().some(item => item.id === entry.competency)),
     ...loadStrategyEvidence().filter((entry) => entry && typeof entry.id === 'string' && typeof entry.competency === 'string'),
   ]
   function enter(doc, catalog) {
@@ -227,7 +227,9 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
       return { ...snapshot(null), ok: false, reject: err.message }
     }
   }
-  function assignment({ node, revision, purpose = 'progress', reason = '' }) {
+  function assignment({ node = '', competency = '', revision, purpose = 'progress', reason = '' }) {
+    if (Boolean(node) === Boolean(competency)) return { ok: false, reject: 'node 与 competency 必须且只能指定一个。', binding: null }
+    if (competency && !loadCompetencies().some(item => item.id === competency)) return { ok: false, reject: 'competency 必须来自已有比赛能力目录。', binding: null }
     const doc = load()
     if (!doc) return { ok: true, reject: '', binding: null }
     if (doc.status !== 'active') return { ok: false, reject: '课程已经完成，请先明确下一条路线。', binding: null }
@@ -237,14 +239,15 @@ export function createCurriculumStore({ dataDir, loadMap, loadProgress, loadSche
     if (!['progress', 'remediation', 'review'].includes(purpose)) return { ok: false, reject: 'purpose 只能是 progress/remediation/review。', binding: null }
     if (purpose === 'progress') {
       if (state.focusExpired) return { ok: false, reject: '本周主线已到期，先复盘并 revise；不会自动换专题。', binding: null }
-      if (!state.focusNodes.includes(node)) return { ok: false, reject: `「${node}」不在当前阶段主线；调整走 revise，补漏/复习要声明 purpose 和 routeReason。`, binding: null }
+      if (competency ? !state.phaseCompetencies.includes(competency) : !state.focusNodes.includes(node)) return { ok: false, reject: `「${node || competency}」不在当前阶段主线；调整走 revise，补漏/复习要声明 purpose 和 routeReason。`, binding: null }
     } else if (clean(reason).length < 10) return { ok: false, reject: '补漏/复习需至少 10 字的 routeReason，说明与当前阶段的关系和回归条件。', binding: null }
-    if (purpose === 'review' && !['learned', 'verified'].includes(loadProgress().nodes?.[node]?.status)) return { ok: false, reject: '复习节点应有学过或已验证的记录；首次学习不能伪装成复习。', binding: null }
-    if (doc.phases[doc.current].kind === 'training') {
+    if (purpose === 'review' && node && !['learned', 'verified'].includes(loadProgress().nodes?.[node]?.status)) return { ok: false, reject: '复习节点应有学过或已验证的记录；首次学习不能伪装成复习。', binding: null }
+    if (node && doc.phases[doc.current].kind === 'training') {
       const missing = prerequisitesOf([node], loadMap().byId).filter((dependency) => !knownNodes(loadProgress()).has(dependency))
       if (missing.length) return { ok: false, reject: `当前训练还缺显式前置记录：${missing.join('、')}；游标不会自动证明前置已掌握。`, binding: null }
     }
-    const other = state.pendingNodes.filter((n) => n !== node)
+    const actionKey = node || `competency:${competency}`
+    const other = state.pendingNodes.filter((n) => n !== actionKey)
     if (other.length) return { ok: false, reject: `当前单元还有未完成动作：${other.join('、')}。先完成或撤销，避免又换一节。`, binding: null }
     return { ok: true, reject: '', binding: { revision: doc.revision, phaseId: state.phaseId,
       phaseTitle: state.phaseTitle, purpose, reason: clean(reason) } }

package/lib/strategy.js

@@ -199,9 +199,16 @@ export function createStrategyStore({ dataDir, vpDir = dataDir, competenciesPath
   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 ?? []
-  const loadProfiles = () => readYaml(contestProfilesPath, () => ({ profiles: [] })).profiles ?? []
+  const loadProfiles = () => (readYaml(contestProfilesPath, () => ({ profiles: [] })).profiles ?? []).map(profile => {
+    const samples = asArray(profile.samples)
+    return { ...profile, samples, coverage: {
+      sampledProblems: samples.length, reviewedSolutions: samples.filter(sample => sample.solutionReviewed === true).length,
+      years: [...new Set(samples.map(sample => sample.year))].sort(), isSyllabus: false,
+    } }
+  })
   const profileFor = id => loadProfiles().find(item => item.id === id) ?? { id: '', title: '', scope: '', status: 'unselected',
-    sources: [], competencyIds: [], selectionGuidance: [], limitations: ['未选择比赛样本配置；不能把通用能力卡当作本场考纲。'] }
+    sources: [], competencyIds: [], selectionGuidance: [], samples: [], coverage: { sampledProblems: 0, reviewedSolutions: 0, years: [], isSyllabus: false },
+    limitations: ['未选择比赛样本配置；不能把通用能力卡当作本场考纲。'] }
 
   function target(action = 'read', args = {}) {
     let old
@@ -356,19 +363,13 @@ export function createStrategyStore({ dataDir, vpDir = dataDir, competenciesPath
     const node = clean(nodeOrId)
     let targetDoc
     try { targetDoc = loadTarget() } catch (err) { return { ok: false, reject: err.message, node, purpose, courseBound: Boolean(courseBound), targetAligned: false, competencyIds: [] } }
-    const base = { node, purpose, courseBound: Boolean(courseBound), targetAligned: true, competencyIds: [] }
-    if (!targetDoc.contest || purpose !== 'progress' || courseBound) return { ok: true, reject: '', ...base }
+    const base = { node, purpose, courseBound: Boolean(courseBound), targetAligned: false, competencyIds: [] }
+    if (!targetDoc.contest) return { ok: true, reject: '', ...base }
     const catalog = loadCompetencies()
     const priorityIds = new Set(targetDoc.priorities.map((item) => item.id))
-    const current = focus()
-    const currentIds = new Set((current.focus ?? []).map((item) => item.id))
     const targetCards = catalog.filter((item) => priorityIds.has(item.id) && item.nodes?.includes(node))
-    const currentCards = targetCards.filter((item) => currentIds.has(item.id))
-    const mappedTarget = catalog.filter((item) => priorityIds.has(item.id) && item.nodes?.length)
-    if (mappedTarget.length && !currentCards.length) {
-      return { ok: false, reject: `「${node}」不服务当前比赛重点；当前重点是 ${current.focus.map((item) => item.id).join('、')}。如果这是课程主线，请带 curriculumRevision；如果是补漏/复习，请声明 purpose 和 routeReason。`, ...base, targetAligned: false, competencyIds: targetCards.map((item) => item.id) }
-    }
-    return { ok: true, reject: '', ...base, targetAligned: currentCards.length > 0, competencyIds: currentCards.map((item) => item.id) }
+    // 能力映射只报事实；优先级排名不能替教练决定这一课。
+    return { ok: true, reject: '', ...base, targetAligned: targetCards.length > 0, competencyIds: targetCards.map((item) => item.id) }
   }
 
   function evidence() {
@@ -401,7 +402,7 @@ export function createStrategyStore({ dataDir, vpDir = dataDir, competenciesPath
     return [
       `- 比赛目标：${t.contest}，目标日期 ${t.date}，结果目标 ${t.result}，团队模式 ${t.teamMode}`,
       `- 距目标日期：${f.daysRemaining}天；剩余时间影响训练取舍，不能只给所有能力乘同一紧急系数。`,
-      `- 比赛样本配置：${f.profile.title || '尚未选择'}（${f.profile.status}）；${f.profile.limitations.join('；')}`,
+      `- 比赛样本配置：${f.profile.title || '尚未选择'}（${f.profile.status}）；覆盖 ${f.profile.coverage.sampledProblems} 题，已核对题解 ${f.profile.coverage.reviewedSolutions} 题；不是完整考纲。${f.profile.limitations.join('；')}`,
       `- 当前目标权重：${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('、')}` : '',

package/lib/teaching.js

@@ -0,0 +1,78 @@
+/** Short lesson continuity notes; teaching judgments never change mastery records. */
+export function createTeachingNotes({ loadProgress, saveProgress, loadMap, getSessionQuery, now = () => new Date().toISOString() }) {
+  const failure = (reject, node = '') => ({ ok: false, reject, node, notes: [], total: 0 })
+  const publicNote = ({ studentEvidence, ...note }) => studentEvidence ? { ...note, studentEvidence } : note
+  const mostRecentNoteNode = (progress, ids) => {
+    let latest = '', latestAt = ''
+    for (const id of ids) {
+      const at = progress.nodes[id]?.lessonNotes?.at(-1)?.at
+      if (at && at >= latestAt) { latest = id; latestAt = at }
+    }
+    return latest
+  }
+  const resolveNode = (progress, node) => {
+    if (node !== undefined) return typeof node === 'string' ? node.trim() : ''
+    return mostRecentNoteNode(progress, Object.keys(progress.pendingActions || {}))
+      || progress.cursor || mostRecentNoteNode(progress, Object.keys(progress.nodes))
+  }
+  const meaningful = (value, max) => typeof value === 'string' && value.trim().length > 0 && value.length <= max
+
+  function read({ node, limit = 5 } = {}) {
+    if (!Number.isInteger(limit) || limit < 1 || limit > 20) return failure('读取条数须为 1 到 20 的整数。')
+    const progress = loadProgress()
+    node = resolveNode(progress, node)
+    if (!node || !loadMap().byId.has(node)) return failure('请指定有效的知识点或先设置游标。', node)
+    const notes = progress.nodes[node]?.lessonNotes || []
+    return { ok: true, reject: '', node, notes: notes.slice(-limit).map(publicNote), total: notes.length }
+  }
+
+  async function write({ node, summary, nextStep, studentQuote }, exec) {
+    if (!meaningful(summary, 1000) || !meaningful(nextStep, 500)) return failure('教学摘要和下次接续必须有内容，分别最多 1000 和 500 字。')
+    if (studentQuote !== undefined && !meaningful(studentQuote, 1500)) return failure('学生原话必须有内容，最多 1500 字。')
+    let progress = loadProgress()
+    node = node === undefined ? (progress.cursor || '') : typeof node === 'string' ? node.trim() : ''
+    if (!node || !loadMap().byId.has(node)) return failure('请指定有效的知识点或先设置游标。', node)
+    let studentEvidence = null
+    if (studentQuote !== undefined) {
+      const sessionId = exec?.agent?.session?.id
+      if (!meaningful(sessionId, 500)) return failure('无法核对学生原话：当前调用缺少会话标识。', node)
+      try {
+        const query = getSessionQuery?.()
+        if (typeof query?.readSession !== 'function') return failure('无法核对学生原话：宿主未提供会话查询服务。', node)
+        const snapshot = await query.readSession(sessionId)
+        if (snapshot?.session?.id && snapshot.session.id !== sessionId) return failure('会话查询返回了其他会话，未写入笔记。', node)
+        const event = Array.isArray(snapshot?.events) && snapshot.events.findLast((event) => {
+          const message = event.data
+          return event.type === 'user/message' && message?.role === 'user' && message.source?.kind === 'user'
+            && Number.isInteger(event.seq) && event.seq >= 0 && meaningful(message.id, 500)
+            && Array.isArray(message.content) && message.content.filter((block) => block.type === 'text' && typeof block.text === 'string').map((block) => block.text).join('\n').includes(studentQuote)
+        })
+        if (!event) return failure('当前会话中没有可核对的这段学生原话，未写入笔记。', node)
+        studentEvidence = { sessionId, seq: event.seq, messageId: event.data.id, quote: studentQuote }
+      } catch {
+        return failure('会话查询失败，学生原话尚未核对，未写入笔记。', node)
+      }
+      // Session lookup yields; keep any progress another tool saved in the meantime.
+      progress = loadProgress()
+    }
+    const record = progress.nodes[node] || {}
+    progress.nodes[node] = { ...record, lessonNotes: [...(record.lessonNotes || []), { at: now(), summary: summary.trim(), nextStep: nextStep.trim(), studentEvidence }] }
+    saveProgress(progress)
+    return read({ node })
+  }
+
+  function context(progress, preferredNode) {
+    const node = resolveNode(progress, preferredNode)
+    const note = progress.nodes[node]?.lessonNotes?.at(-1)
+    if (!note) return ''
+    const clip = (text, length) => text.replace(/\s+/g, ' ').slice(0, length)
+    const lines = [
+      `续课笔记 · ${clip(node, 60)} · ${note.at}`,
+      `教练判断：${clip(note.summary, 200)}`,
+      note.studentEvidence ? `学生原话已核对（不代表掌握）：${clip(note.studentEvidence.quote, 120)}` : '尚无学生原话依据；这是教练的教学观察。',
+      `下次接续建议（可调整）：${clip(note.nextStep, 220)}`,
+    ]
+    return lines.join('\n')
+  }
+  return { read, write, context }
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "acmer-coach",
-  "description": "小鲸教练插件：把「位置 + 判断」从小鲸的转述里拿回来。读 MAP/DEPENDS/PROGRESS，给唯一动作、判因、检测。热插拔，删掉即还原。",
-  "version": "2.4.0",
+  "description": "小鲸教练插件：保存训练位置和真实证据，支持教练判断、持续教学与比赛备赛。读 MAP/DEPENDS/PROGRESS，提供训练、判因和检测工具。",
+  "version": "2.6.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/Miantiao1231/acmer-coach.git"
@@ -23,7 +23,7 @@
     "@deepseek-ai/dsh-tools": "0.2.0-rc.2"
   },
   "scripts": {
-    "test": "node --test dev/curriculum-check.mjs dev/curriculum-evidence-check.mjs dev/strategy-check.mjs dev/catalog-check.mjs dev/coaching-contract-check.mjs dev/workspace-migration-check.mjs dev/vp-client-check.mjs dev/vp-sync-check.mjs"
+    "test": "node --test dev/curriculum-check.mjs dev/curriculum-evidence-check.mjs dev/strategy-check.mjs dev/catalog-check.mjs dev/coaching-contract-check.mjs dev/teaching-check.mjs dev/grading-check.mjs dev/training-check.mjs dev/workspace-migration-check.mjs dev/vp-client-check.mjs dev/vp-sync-check.mjs"
   },
   "dsh": {
     "engines": {

package/verify-shape.mjs

@@ -17,6 +17,7 @@
 // 退出码非 0 = 有错配。
 
 import { mkdtempSync, writeFileSync } from 'node:fs'
+import assert from 'node:assert/strict'
 import os from 'node:os'
 import path from 'node:path'
 import { pathToFileURL } from 'node:url'
@@ -136,7 +137,7 @@ function validate(schema, value, at, errs) {
       if (!(k in props)) errs.push(`${at}.${k}: schema 未声明（additionalProperties:false → dsh 校验会拒）`)
     }
     for (const [k, s] of Object.entries(props)) {
-      if (!(k in value)) { if (s.required) errs.push(`${at}.${k}: 缺 required 字段`); continue }
+      if (!(k in value)) { if (s.required === true || (Array.isArray(schema.required) && schema.required.includes(k))) errs.push(`${at}.${k}: 缺 required 字段`); continue }
       validate(s, value[k], `${at}.${k}`, errs)
     }
   } else if (t === 'array') {
@@ -153,6 +154,21 @@ function validate(schema, value, at, errs) {
   }
 }
 
+// 嵌套对象的 required 列表描述子字段，不代表这个对象自身必填。
+const optionalObjectSchema = { type: 'object', required: ['summary'], properties: {
+  summary: { type: 'string' },
+  studentEvidence: { type: 'object', required: ['quote'], properties: { quote: { type: 'string' } } },
+} }
+const validOptional = [], missingParent = [], missingChild = [], missingDsl = []
+validate(optionalObjectSchema, { summary: '教练判断' }, 'out', validOptional)
+validate(optionalObjectSchema, {}, 'out', missingParent)
+validate(optionalObjectSchema, { summary: '教练判断', studentEvidence: {} }, 'out', missingChild)
+validate({ type: 'object', properties: { summary: { type: 'string', required: true } } }, {}, 'out', missingDsl)
+assert.deepEqual(validOptional, [])
+assert.deepEqual(missingParent, ['out.summary: 缺 required 字段'])
+assert.deepEqual(missingChild, ['out.studentEvidence.quote: 缺 required 字段'])
+assert.deepEqual(missingDsl, ['out.summary: 缺 required 字段'])
+
 const mod = await import(`${INSTALLED}?sweep=${Date.now()}`)
 const registered = []
 mod.apply(mockCtx(registered))
@@ -169,10 +185,10 @@ const cases = [
   ['coach_ping', {}],
   ['coach_target', { action: 'read' }],
   ['coach_target', { action: 'set', expectedRevision: 0, contest: '测试区域赛', date: '2026-10-18', result: '金牌', teamMode: 'team', weeklyHours: 20, priorities: [{ id: 'contest-reading', weight: 80, reason: '测试目标' }] }],
-  // 真正走一遍「目标 → 动作」硬闸：不属于当前能力的 progress 节点必须拒绝，
+  // 目标能力提供关联提示；没有映射的节点仍可由教练解释后安排，
   // 再切回无地图能力的读题卡，保留后续旧夹具的成功路径。
   ['coach_target', { action: 'set', expectedRevision: 1, contest: '测试区域赛', date: '2026-10-18', result: '金牌', teamMode: 'team', weeklyHours: 20, priorities: [{ id: 'dp-modeling', weight: 80, reason: '测试硬闸' }] }],
-  ['coach_assign#target-gate', { node: 'B', deliverable: '把代码贴给我', why: '测试目标硬闸', minutes: 60, teachMinutes: 25 }],
+  ['coach_assign#target-advisory', { node: 'B', deliverable: '把代码贴给我', why: '测试未映射节点仍可训练', minutes: 60, teachMinutes: 25 }],
   ['coach_target', { action: 'set', expectedRevision: 2, contest: '测试区域赛', date: '2026-10-18', result: '金牌', teamMode: 'team', weeklyHours: 20, priorities: [{ id: 'contest-reading', weight: 80, reason: '测试目标' }] }],
   ['coach_vp_import', { events: [{ eventId: 'shape-vp', contest: '测试 VP', date: today, durationMinutes: 300, problems: [{ problemId: 'A', status: 'AC', competencies: ['contest-reading'] }] }] }],
   ['coach_vp_connect', { action: 'status' }],
@@ -206,6 +222,12 @@ const cases = [
   ['coach_next', { cursor: '并不存在' }],              // 打错字
   ['coach_next', {}],                                  // 游标空 → 读夹具
   ['coach_status', {}],
+  ['coach_note#read', { action: 'read', node: 'B' }],
+  ['coach_note#write', { action: 'write', node: 'B', summary: '已说明状态需要保留哪些历史；还没收到学生回应。', nextStep: '接着核对能否区分两段未来不同的历史。' }],
+  ['coach_note#read-saved', { action: 'read', node: 'B', limit: 5 }],
+  ['coach_note#quote-rejected', { action: 'write', node: 'B', summary: '待核实回应', nextStep: '核对原话', studentQuote: '我理解了这个状态的定义。' }],
+  ['coach_note#invalid-node', { action: 'write', node: 'ZZZ', summary: '测试笔记', nextStep: '继续' }],
+  ['coach_note#empty-summary', { action: 'write', node: 'B', summary: '', nextStep: '继续' }],
   ['coach_set_cursor', { node: 'B' }],
   ['coach_set_cursor', { node: 'ZZZ' }],               // 拒
   ['coach_mark', { node: 'C', status: 'studying' }],
@@ -307,11 +329,19 @@ for (const [name, args, preset] of cases) {
     bad++
     continue
   }
-  if (name === 'coach_assign#target-gate' && out.accepted !== false) {
-    console.log(`  FAIL ${name}  → 目标硬闸没有拒绝无关 progress 节点`)
+  if (name === 'coach_assign#target-advisory' && (out.accepted !== true || out.targetAligned !== false)) {
+    console.log(`  FAIL ${name}  → 未映射节点应允许布置，并明确 targetAligned=false`)
     bad++
     continue
   }
+  if (name.startsWith('coach_note#')) {
+    const rejected = ['quote-rejected', 'invalid-node', 'empty-summary'].includes(name.split('#')[1])
+    if (out.ok === rejected || (!rejected && name !== 'coach_note#read' && out.notes?.length !== 1)) {
+      console.log(`  FAIL ${name}  → 续课笔记的成功/拒绝或落盘结果不符`)
+      bad++
+      continue
+    }
+  }
   const errs = []
   validate(tool.output.schema, out, 'out', errs)
   let renderNote = ''