daily-question 2.1.0 → 2.1.2

package/cordis.patch.yml

@@ -1,7 +1,7 @@
 # 考研每日一题 bundle patch
 #
 # 插入一个宿主插件行：持有题库、答题记录、追问线程与考研日期核验，
-# 并通过 ctx.webServer 暴露 /api/daily-question/* 供本包的 Client 半调用。
+# 并通过宿主 Connection 注册鉴权接口供本包的 Client 半调用。
 - insert:
     - id: daily-question
       name: daily-question

package/icon.svg

@@ -1,11 +1,14 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" width="24" height="24" role="img" aria-label="考研每日一题">
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64" role="img" aria-label="考研每日一题">
   <defs>
-    <linearGradient id="kdGrad" x1="0" y1="0" x2="1" y2="1">
-      <stop offset="0" stop-color="#4d6bfe"/>
-      <stop offset="1" stop-color="#7a4dfe"/>
+    <linearGradient id="dq-blue" x1="0" y1="0" x2="1" y2="1">
+      <stop offset="0" stop-color="#5676ff"/>
+      <stop offset="1" stop-color="#3b55e8"/>
     </linearGradient>
   </defs>
-  <path fill="url(#kdGrad)" d="M4.6 2h14.8A2.6 2.6 0 0 1 22 4.6v14.8A2.6 2.6 0 0 1 19.4 22H4.6A2.6 2.6 0 0 1 2 19.4V4.6A2.6 2.6 0 0 1 4.6 2Z"/>
-  <path fill="#fff" d="M7 5.2c.5 0 .9.4.9.9v.9h8.2v-.9a.9.9 0 0 1 1.8 0v.9h.3c.9 0 1.6.7 1.6 1.6v8.6c0 .9-.7 1.6-1.6 1.6H5.8c-.9 0-1.6-.7-1.6-1.6V8.6c0-.9.7-1.6 1.6-1.6h.3v-.9c0-.5.4-.9.9-.9Zm10.9 4.4H6.1v6.9c0 .1 0 .1.1.1h11.6c.1 0 .1 0 .1-.1V9.6Z"/>
-  <path fill="#fff" d="M10.3 13.6a.8.8 0 0 1 1.1 0l.9.9 2.1-2.1a.8.8 0 0 1 1.1 1.1l-2.6 2.6a.8.8 0 0 1-1.1 0l-1.5-1.5a.8.8 0 0 1 0-1Z"/>
+  <rect x="2" y="2" width="60" height="60" rx="16" fill="url(#dq-blue)"/>
+  <g fill="none" stroke="#fff" stroke-linecap="round" stroke-linejoin="round">
+    <rect x="15.5" y="20" width="33" height="30" rx="6.5" stroke-width="3.6"/>
+    <path d="M23 15.5V23M41 15.5V23" stroke-width="3.6"/>
+    <path d="m27.4 33.2 5.5-3.9v13.3m-4.4 0h9.2" stroke-width="4"/>
+  </g>
 </svg>

package/index.js

@@ -6,7 +6,7 @@ import { registerRoutes } from './lib/routes.js'
  *
  * 职责：题库与学习数据的持久化、在线出题 + 独立答案校验、
  * 答案详解的固定版本、按题目隔离的追问线程、考研日期核验，
- * 以及把这些能力通过 ctx.webServer 的同源接口暴露给本包的 Client 半。
+ * 以及通过宿主 Connection 的鉴权接口向本包的 Client 半提供这些能力。
  *
  * 界面全部由 client.js 以 Slot 组件渲染；这里不提供 HTML 页面。
  */
@@ -38,13 +38,13 @@ export function apply(ctx) {
     return () => { stopped = true; service.dispose() }
   }, `${PREFIX}.store`)
 
-  ctx.inject(['webServer'], (scoped) => {
-    const webServer = scoped.webServer
-    if (!webServer || typeof webServer.register !== 'function') {
-      logger.warn?.('webServer 不可用，界面接口没有启动')
+  ctx.inject(['connection'], (scoped) => {
+    const connection = scoped.connection
+    if (typeof connection?.fetch?.register !== 'function') {
+      logger.warn?.('宿主 Connection Fetch 不可用，界面接口没有启动')
       return undefined
     }
-    return registerRoutes(webServer, service, logger)
+    return registerRoutes(connection, service, logger)
   })
 }
 

package/lib/bank.js

@@ -1,4 +1,4 @@
-import { CHOICE_TYPES, QUESTION_TYPE_LABEL } from './subjects.js'
+import { CHOICE_TYPES, QUESTION_TYPE_LABEL, hasChoiceOptions, validChoiceKey } from './subjects.js'
 import { extractPdfTextAsync } from './pdf.js'
 
 /**
@@ -9,13 +9,15 @@ import { extractPdfTextAsync } from './pdf.js'
  */
 
 const OPTION_LINE = /^\s*(?:[（(]\s*([A-H])\s*[)）]|([A-H])\s*[.、．:：)）])\s*(.+)$/
-const QUESTION_START = /^\s*(?:#{1,6}\s*)?(?:第\s*)?(\d{1,4})\s*(?:题|[.、．)）])\s*(.*)$/
+const QUESTION_START = /^\s*((?:#{1,6}\s*)?(?:第\s*)?)(\d{1,4})\s*(题|[.、．)）])\s*(.*)$/
 const LABEL_LINE = /^\s*(?:【?\s*(答案|参考答案|正确答案|解析|详解|答案详解|【解析】|分析|知识点|考点|难度|题型|答|解)\s*】?\s*[:：]\s*)(.*)$/
 const HARD_SEPARATOR = /^\s*(?:-{3,}|\*{3,}|={3,})\s*$/
 const BRACKET_MARK = /^\s*【\s*(题目|题干|问题)\s*】\s*(.*)$/
 const TYPE_WORDS = [
-  ['single', ['单项选择', '单选', '选择题']],
+  ['cloze', ['完形填空', '英语知识运用']],
+  ['reading', ['阅读理解']],
   ['multiple', ['多项选择', '多选']],
+  ['single', ['单项选择', '单选', '选择题']],
   ['fill', ['填空']],
   ['solution', ['解答', '计算', '证明', '综合应用', '算法设计', '综合题']],
   ['analysis', ['分析题', '材料分析']],
@@ -24,6 +26,12 @@ const TYPE_WORDS = [
   ['shortanswer', ['简答']],
 ]
 
+function answerSection(name) {
+  if (/解析|详解|^(分析|解)$/.test(name)) return 'explanation'
+  if (/答案|^答$/.test(name)) return 'answer'
+  return null
+}
+
 /** 判断一行是否处于 ``` 代码围栏内，用于避免在代码块里切分题目。 */
 function fenceTracker() {
   let inside = false
@@ -41,29 +49,42 @@ function splitBlocks(text) {
   const isFenced = fenceTracker()
   const blocks = []
   let current = []
+  let inAnswer = false
+  let questionNumber = null
+  let blankBefore = false
   const push = () => {
     const body = current.join('\n').trim()
     if (body) blocks.push(body)
     current = []
+    inAnswer = false
+    questionNumber = null
   }
   for (const line of lines) {
     const fenced = isFenced(line)
-    if (!fenced && (HARD_SEPARATOR.test(line) || BRACKET_MARK.test(line) || (QUESTION_START.test(line) && current.join('\n').trim()))) {
-      if (BRACKET_MARK.test(line)) {
-        push()
-        const rest = BRACKET_MARK.exec(line)[2]
-        current = [rest].filter(Boolean)
-        continue
-      }
-      if (HARD_SEPARATOR.test(line)) {
-        push()
-        continue
-      }
+    const bracket = fenced ? null : BRACKET_MARK.exec(line)
+    if (bracket || (!fenced && HARD_SEPARATOR.test(line))) {
       push()
-      current = [line]
+      if (bracket?.[2]) current.push(bracket[2])
+      blankBefore = false
       continue
     }
+    const numbered = fenced ? null : QUESTION_START.exec(line)
+    if (numbered) {
+      const [, prefix, digits, suffix, stem] = numbered
+      const number = Number(digits)
+      const explicit = prefix || suffix === '题'
+      // shortcut: 裸数字题号与解析步骤有歧义，低置信度时请用“第 N 题”或分隔线。
+      const nextQuestion = blankBefore && number === questionNumber + 1
+        && (/^(?:已知|设|下列|试问|证明[:：]|计算[:：])/.test(stem) || /[?？]$/.test(stem))
+      if (explicit || !inAnswer || nextQuestion) {
+        push()
+        questionNumber = number
+      }
+    }
+    const label = fenced ? null : LABEL_LINE.exec(line)
+    if (label && answerSection(label[1].replace(/[【】]/g, ''))) inAnswer = true
     current.push(line)
+    blankBefore = !line.trim()
   }
   push()
   return blocks
@@ -121,14 +142,10 @@ export function parseBlock(block, index) {
     if (label) {
       const name = label[1].replace(/[【】]/g, '')
       const rest = label[2].trim()
-      if (name.includes('答案') || name === '答') {
-        section = 'answer'
-        if (rest) sections.answer.push(entry)
-        continue
-      }
-      if (name.includes('解析') || name.includes('详解') || name === '分析' || name === '解') {
-        section = 'explanation'
-        if (rest) sections.explanation.push(entry)
+      const contentSection = answerSection(name)
+      if (contentSection) {
+        section = contentSection
+        if (rest) sections[section].push({ ...entry, text: rest })
         continue
       }
       if (name === '知识点' || name === '考点') {
@@ -153,9 +170,9 @@ export function parseBlock(block, index) {
     sections[section].push(entry)
   }
 
-  const stemEntries = sections.stem.map((entry) => ({
+  const stemEntries = sections.stem.map((entry, index) => ({
     ...entry,
-    text: QUESTION_START.test(entry.text) && !entry.fenced ? entry.text.replace(QUESTION_START, '$2').trim() : entry.text,
+    text: index === 0 && !entry.fenced ? entry.text.replace(QUESTION_START, '$4').trim() : entry.text,
   }))
   const optionLines = stemEntries.filter((entry) => !entry.fenced && OPTION_LINE.test(entry.text))
   const stemBody = stemEntries.filter((entry) => entry.fenced || !OPTION_LINE.test(entry.text))
@@ -184,21 +201,16 @@ export function parseBlock(block, index) {
   const issues = []
   if (!stemBody) issues.push('未识别到题干')
   else if (stemBody.length < 6) issues.push('题干过短，可能识别不完整')
-  if (CHOICE_TYPES.has(type) && options.length < 2) issues.push('选择题未识别到选项')
+  if (CHOICE_TYPES.has(type) && !hasChoiceOptions(options)) issues.push('选择题需要至少两个不同且有效的选项')
   if (!answerRaw) issues.push('没有参考答案（标记为缺少参考答案）')
   if (!explanation) issues.push('没有解析（可稍后补充）')
   if (optionLines.length && !options.length) issues.push('选项行格式无法识别')
 
   let answerKey = ''
   const answerLetters = CHOICE_TYPES.has(type) ? lettersOf(answerRaw) : ''
-  if (CHOICE_TYPES.has(type)) {
-    if (answerLetters && options.every((option) => option.key !== answerLetters[0])) {
-      issues.push('参考答案的选项字母不在选项列表中')
-    } else if (type === 'single' && answerLetters.length > 1) {
-      issues.push('参考答案给出多个选项，题型可能应为多项选择题')
-    } else if (answerLetters) {
-      answerKey = answerLetters
-    }
+  if (answerLetters) {
+    if (validChoiceKey(type, answerLetters, options)) answerKey = [...answerLetters].sort().join('')
+    else issues.push('参考答案与题型或选项不匹配，将由用户自行判定')
   }
 
   return {
@@ -219,6 +231,11 @@ export function parseBlock(block, index) {
   }
 }
 
+export function isUsableBankItem(item) {
+  return typeof item.stem === 'string' && item.stem.trim().length >= 6
+    && (!CHOICE_TYPES.has(item.type) || hasChoiceOptions(item.options))
+}
+
 /** 像标题、说明或分隔块的片段：不含选项/答案/解析，且不像一道题。 */
 function isHeaderBlock(item) {
   if (item.options.length || item.answer || item.explanation || item.knowledge.length) return false
@@ -259,8 +276,8 @@ export function parseBankText(text, { filename = '' } = {}) {
   if (items.length === 1) {
     warnings.push('只识别到 1 道题：如果这是多题题库，请用“题号 / --- / 【题目】”等分隔符分开每道题')
   }
-  const usable = items.filter((item) => item.stem && item.options.length + item.answer.length > 0).length
-  if (!usable) warnings.push('没有可用题目：题干、选项与答案都没有被正确识别')
+  const usable = items.filter(isUsableBankItem).length
+  if (!usable) warnings.push('没有可用题目：请检查题干及选择题选项是否完整')
   if (filename) warnings.push(`来源文件：${filename}`)
   return { items, warnings, usable }
 }

package/lib/exam-dates.js

@@ -1,3 +1,5 @@
+import { abortable } from './async.js'
+
 /**
  * 考研日期的权威性处理。
  *
@@ -269,93 +271,125 @@ export function computeCountdown(year, examInfo, today = todayISO()) {
 }
 
 function stripHtml(html) {
-  return String(html || '')
-    .replace(/<script[\s\S]*?<\/script>/gi, ' ')
-    .replace(/<style[\s\S]*?<\/style>/gi, ' ')
+  return html
+    .replace(/<!--[\s\S]*?-->/g, ' ')
+    .replace(/<(head|title|script|style|nav|aside|footer|a)\b[^>]*>[\s\S]*?<\/\1\s*>/gi, ' ')
+    .replace(/\r?\n/g, ' ')
+    .replace(/<\/(?:p|div|li|tr|h[1-6])\s*>|<br\b[^>]*>/gi, '\n')
     .replace(/<[^>]+>/g, ' ')
-    .replace(/&nbsp;/g, ' ')
+    .replace(/&(?:nbsp|#160|#xa0);/gi, ' ')
     .replace(/&amp;/g, '&')
     .replace(/&lt;/g, '<')
     .replace(/&gt;/g, '>')
-    .replace(/\s+/g, ' ')
 }
 
-function isOfficialHost(url) {
+function officialUrl(value) {
   try {
-    const host = new URL(url).hostname.toLowerCase()
-    return OFFICIAL_HOSTS.some((suffix) => host === suffix || host.endsWith(`.${suffix}`))
+    const url = new URL(value)
+    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password) return null
+    if (!OFFICIAL_HOSTS.some((host) => url.hostname === host || url.hostname.endsWith('.' + host))) return null
+    url.hash = ''
+    return url.href
   } catch {
-    return false
+    return null
   }
 }
 
-/**
- * 联网核验某年的考试日期。
- *
- * 只在教育部 / 教育考试院 / 研招网域名命中“初试时间为 YYYY 年 12 月 D 日”时
- * 才认定为官方公布；否则如实返回未核实，不做任何猜测。
- */
+function examSessions(text) {
+  return Array.from(text.matchAll(/(\d{4})年?(?:(?:全国)?硕士研究生招生|考研|研考)/g), (match) => Number(match[1]))
+}
+
+function readExamDates(body, year) {
+  if (typeof body?.content !== 'string' || !['html', 'text'].includes(body.kind)) return null
+  const html = body.kind === 'html'
+  const title = html ? stripHtml(/<title\b[^>]*>([\s\S]*?)<\/title\s*>/i.exec(body.content)?.[1] || '').trim() : ''
+  const heading = html ? stripHtml(/<h([12])\b[^>]*>([\s\S]*?)<\/h\1\s*>/i.exec(body.content)?.[2] || '') : ''
+  const paragraphs = html ? stripHtml(body.content.replace(/<h([1-6])\b[^>]*>[\s\S]*?<\/h\1\s*>/gi, '<br>')) : body.content
+  const text = paragraphs.normalize('NFKC').replace(/[^\S\r\n]+/g, '')
+  const titleYears = examSessions(title.normalize('NFKC').replace(/\s+/g, ''))
+  const pageYears = titleYears.length ? titleYears : examSessions(heading.normalize('NFKC').replace(/\s+/g, '') + '\n' + text)
+  if (!pageYears.includes(year)) return null
+
+  const examYear = year - 1
+  const pattern = new RegExp(`初试时间(?:为|是|定于|安排在|调整为)?:?${examYear}年12月(\\d{1,2})日?(?:至|到|[-–—~])(?:(?:${examYear}年)?12月)?(\\d{1,2})日`, 'g')
+  let result = null
+  for (const sentence of text.split(/[\r\n。；;，,]+/)) {
+    const years = examSessions(sentence)
+    if (years.length && !years.includes(year)) continue
+    for (const match of sentence.matchAll(pattern)) {
+      const start = Number(match[1])
+      const end = Number(match[2])
+      if (start < 1 || end < start || end > 31) continue
+      const date = `${examYear}-12-${pad2(start)}`
+      const endDate = `${examYear}-12-${pad2(end)}`
+      if (result && (result.date !== date || result.endDate !== endDate)) return null
+      result = { date, endDate, title, snippet: match[0] }
+    }
+  }
+  return result
+}
+
+/** 仅采信目标届次的官方正文明确给出的完整初试区间。 */
 export async function verifyExamDateOnline({ year, web, signal, fetchLimit = 3 }) {
   const checked = []
-  const now = new Date().toISOString()
-  if (!web || typeof web.search !== 'function') {
+  if (typeof web?.search !== 'function' || typeof web?.fetch !== 'function') {
     return { ok: false, reason: 'web 服务不可用，无法联网核验官方日期', checked }
   }
+  if (!Number.isInteger(year) || year < 1001 || year > 9999) return { ok: false, reason: '考研届次无效', checked }
   const expectYear = year - 1
-  let sources = []
-  try {
-    const result = await web.search({ query: `${year}年全国硕士研究生招生考试 初试时间 12月`, maxResults: 8 }, signal)
-    sources = Array.isArray(result?.sources) ? result.sources : []
-  } catch (error) {
-    return { ok: false, reason: `联网检索失败：${error?.message || error}`, checked }
-  }
-
-  const official = sources.filter((item) => item && item.url && isOfficialHost(item.url)).slice(0, fetchLimit)
-  if (!official.length) {
-    return {
-      ok: false,
-      reason: `没有检索到 ${year} 考研在官方渠道（moe.gov.cn / chsi.com.cn / neea.edu.cn）发布的初试日期，保持“尚未核实/估算”状态`,
-      checked: sources.map((item) => item.url).slice(0, 8),
-    }
-  }
-
-  for (const source of official) {
-    checked.push(source.url)
+  const visited = new Set()
+  let searched = false
+  let searchError
+  for (const host of OFFICIAL_HOSTS) {
+    if (signal?.aborted) break
+    const subject = host === 'moe.gov.cn' ? '招生工作管理规定' : '招生考试'
+    const query = `site:${host} ${year}年全国硕士研究生${subject} 初试时间 ${expectYear}年12月`
+    let sources
     try {
-      const page = await web.fetch({ url: source.url }, signal)
-      const text = page?.body?.kind === 'html' ? stripHtml(page.body.content) : String(page?.body?.content || '')
-      const match = new RegExp(`初试时间[^。；]{0,40}?${expectYear}年12月(\\d{1,2})日`).exec(text)
-        || new RegExp(`${expectYear}年12月(\\d{1,2})日至`).exec(text)
-      if (!match) continue
-      const day = Number(match[1])
-      if (!(day >= 1 && day <= 31)) continue
-      const date = `${expectYear}-12-${pad2(day)}`
-      return {
-        ok: true,
-        record: {
-          date,
-          endDate: addDays(date, 1),
-          status: 'official',
-          source: source.title || source.url,
-          sourceUrl: source.url,
-          publishedAt: source.publishedAt || '',
-          verifiedAt: now,
-          method: 'online-search',
-          note: `由官方渠道页面核验：${source.url}`,
-        },
-        checked,
-        snippet: match[0],
-      }
+      const result = await abortable(() => web.search({ query, maxResults: 8 }, signal), signal)
+      searched = true
+      sources = Array.isArray(result?.sources) ? result.sources : []
     } catch (error) {
-      checked.push(`${source.url} (${error?.message || error})`)
+      searchError = error
+      continue
+    }
+    let fetched = 0
+    for (const source of sources) {
+      if (signal?.aborted || fetched >= fetchLimit) break
+      const url = officialUrl(source?.url)
+      if (!url || visited.has(url)) continue
+      visited.add(url)
+      fetched++
+      try {
+        const page = await abortable(() => web.fetch({ url }, signal), signal)
+        const finalUrl = officialUrl(page?.url || url)
+        const found = finalUrl && readExamDates(page?.body, year)
+        checked.push(url)
+        if (!found) continue
+        return {
+          ok: true,
+          record: {
+            date: found.date,
+            endDate: found.endDate,
+            status: 'official',
+            source: found.title || source.title || finalUrl,
+            sourceUrl: finalUrl,
+            publishedAt: source.publishedAt || '',
+            verifiedAt: new Date().toISOString(),
+            method: 'online-search',
+            note: `由官方渠道页面核验：${finalUrl}`,
+          },
+          checked,
+          snippet: found.snippet,
+        }
+      } catch (error) {
+        checked.push(`${url} (${error?.message || error})`)
+      }
     }
   }
-
-  return {
-    ok: false,
-    reason: `检索到官方渠道页面，但未能在其中确认 ${expectYear}年12月的初试日期`,
-    checked,
-  }
+  if (signal?.aborted) return { ok: false, reason: '联网核验已超时或取消', checked }
+  if (!searched) return { ok: false, reason: `联网检索失败：${searchError?.message || searchError}`, checked }
+  return { ok: false, reason: `未能从官方正文确认 ${year} 考研（${expectYear}年12月）的初试起止日期`, checked }
 }
 
 export function addDays(iso, days) {

package/lib/generate.js

@@ -1,7 +1,8 @@
-import { describeSubjectForPrompt, QUESTION_TYPE_LABEL, CHOICE_TYPES } from './subjects.js'
+import { describeSubjectForPrompt, QUESTION_TYPE_LABEL, CHOICE_TYPES, hasChoiceOptions, validChoiceKey } from './subjects.js'
 import { asString, asStringArray, generateText, parseJsonLoose, resolveModel } from './llm-json.js'
 import { loadExamReferences, reviewExamFit } from './references.js'
-import { generationPlan,findQuestionRepeat } from './generation-history.js'
+import { generationPlan,findQuestionRepeat,rankQuestionTypes } from './generation-history.js'
+import { papersForType, typeLabel } from './paper-types.js'
 
 /**
  * 在线出题 = 三个互相独立的步骤：
@@ -34,7 +35,7 @@ const WRITER_SYSTEM = `你是一位中国大陆硕士研究生招生考试的命
 
 const SOLVER_SYSTEM = `你是一位独立解题专家。请求中只有题干和选项，不提供命题答案或解析。
 请独立求解，检查题干条件、可解性和唯一性；不要猜测命题人的答案。
-选择题在 answerKey 中写正确选项字母，多选去重并升序；其他题型留空。
+单选、完形和阅读在 answerKey 中只写一个正确选项字母；多选去重并升序；非选择题留空。
 只输出 JSON：{"solvable":true,"answer":"最终答案","answerKey":"","explanation":"完整推导、依据及易错点，不少于20字","issues":[]}。
 无法确定时 solvable 为 false，并在 issues 中说明原因。`
 
@@ -71,8 +72,23 @@ export async function createVerifiedQuestion({ ctx, subject, examInfo, signal, p
     const selection = resolveModel(ctx)
     modelIdentity = `${selection.provider}/${selection.model}`
   } catch { /* 模型信息缺失不影响出题，校验记录里留空即可 */ }
-  const references = await loadExamReferences({ ctx, subject, examInfo, signal })
-  const plan=generationPlan({subject,references,history,preferredType})
+  const typeOrder = rankQuestionTypes(subject,history,preferredType)
+  const plannedType = typeOrder[0]
+  const loaded = await loadExamReferences({ ctx, subject, examInfo, signal, plannedType })
+  const scopeReferences = {...loaded,sources:loaded.sources.filter((source) => source.kind !== 'paper')}
+  const papers = loaded.sources.filter((source) => source.kind === 'paper')
+  let selectedType = plannedType
+  let sameTypePapers = []
+  for (const type of typeOrder) {
+    const matching = papersForType(papers,type,typeOrder)
+    if (matching.length < 2) continue
+    selectedType = type
+    sameTypePapers = matching
+    break
+  }
+  const verifyDifficulty = sameTypePapers.length >= 2
+  const references = {...scopeReferences,sources:[...scopeReferences.sources,...sameTypePapers]}
+  const plan=generationPlan({subject,references,history,preferredType:selectedType})
   const typeHint=plan.type
 
   for (let attempt = 1; attempt <= MAX_GENERATION_ATTEMPTS; attempt += 1) {
@@ -97,7 +113,7 @@ export async function createVerifiedQuestion({ ctx, subject, examInfo, signal, p
     }
     const candidate = normalizeCandidate(draft, allowed)
     const problems = structuralProblems(candidate, allowed)
-    if(candidate.type!==typeHint)problems.push('本轮需采用近期较少出现的指定题型：'+typeHint)
+    if(candidate.type!==typeHint)problems.push('本轮需采用指定题型：'+typeHint)
     const repeated=findQuestionRepeat(candidate,plan.index)
     if(repeated)problems.push(repeated+'，必须换一道新题，不要仅调整措辞或参数')
     if (rejectedStem && candidate.stem.replace(/\s+/g, '') === rejectedStem) problems.push('重新命题复用了已被拒绝的题干，必须换一道新题')
@@ -113,17 +129,41 @@ export async function createVerifiedQuestion({ ctx, subject, examInfo, signal, p
 
     if (review.pass) {
       let fit
-      try { fit = await reviewExamFit({ ctx, subject, candidate: review.candidate, references, signal, coverageTarget:plan.topic }) }
-      catch (error) { fit = { passed: false, issues: ['范围与难度评审失败：' + error.message] } }
-      trail.push({ attempt, stage: 'exam-fit', passed: fit.passed, summary: fit.rationale || '范围与难度未通过', issues: fit.issues })
+      let difficultyNote = verifyDifficulty ? '' : `补检后仍未取得至少两个年份的${typeLabel(typeHint)}有效真题正文。`
+      let difficultyIssues = []
+      const reviewInput = { ctx, subject, candidate: review.candidate, signal, coverageTarget:plan.topic }
+      if (verifyDifficulty) {
+        try {
+          fit = await reviewExamFit({ ...reviewInput, references })
+          if (fit.difficultyUnavailable) {
+            difficultyNote = '独立评审确认现有真题材料不足以完成难度对照。'
+            difficultyIssues = fit.issues
+          }
+        } catch (error) {
+          signal?.throwIfAborted()
+          difficultyNote = '独立难度评审未能返回可核对的结果。'
+        }
+      }
+      if (difficultyNote) {
+        try { fit = await reviewExamFit({ ...reviewInput, references:scopeReferences, verifyDifficulty:false }) }
+        catch (error) {
+          signal?.throwIfAborted()
+          fit = { passed: false, issues: ['独立大纲范围评审失败：' + error.message] }
+        }
+      }
+      trail.push({ attempt, stage: 'exam-fit', passed: fit.passed, summary: fit.rationale || '独立评审未通过', issues: fit.issues })
       if (!fit.passed) {
         feedback = '题目答案已核验，但范围或难度不符合真实考试，请重新命题：' + fit.issues.join('；')
         rejectedStem = candidate.stem.replace(/\s+/g, '')
         continue
       }
-      const examAlignment = { status: 'passed', difficulty: fit.difficulty, rationale: fit.rationale, warnings:fit.warnings || [],
+      const evidence = difficultyNote ? scopeReferences : references
+      const examAlignment = { ...evidence,
+        status: difficultyNote ? 'difficulty-unverified' : 'passed', difficulty: fit.difficulty,
+        note: difficultyNote ? `未通过真题难度校验。${difficultyNote}已独立核对大纲范围。` : references.note,
+        rationale: fit.rationale, warnings:[...difficultyIssues,...(fit.warnings || [])],
         outlineEvidence: fit.outlineEvidence, paperEvidence: fit.paperEvidence,
-        ...references, sources: references.sources.map(({ text, ...source }) => source) }
+        sources: evidence.sources.map(({ text, ...source }) => source) }
       const verification = {
         status: 'passed',
         at: new Date().toISOString(),
@@ -133,9 +173,9 @@ export async function createVerifiedQuestion({ ctx, subject, examInfo, signal, p
         attempts: attempt,
         model: modelIdentity,
         trail,
-        coverage:{type:typeHint,topic:plan.topic,recentWindow:30,historyCount:plan.historyCount},
+        coverage:{type:typeHint,plannedType,topic:plan.topic,recentWindow:30,historyCount:plan.historyCount},
       }
-      return { question: { ...review.candidate, coverageTopic:plan.topic, difficulty: fit.difficulty, examAlignment }, verification }
+      return { question: { ...review.candidate, coverageTopic:plan.topic, difficulty: fit.difficulty ?? review.candidate.difficulty, examAlignment }, verification }
     }
 
     rejectedStem = candidate.stem.replace(/\s+/g, '')
@@ -170,7 +210,7 @@ async function writeQuestion({ ctx, subject, examInfo, allowed, allowedLabels, t
     '  "stem": "题干（Markdown + LaTeX）",',
     '  "options": [{"key": "A", "text": "选项内容（Markdown + LaTeX）"}],   // 选择题必填，其他题型为空数组',
     '  "answer": "标准答案（Markdown）。选择题为正确选项字母，例如 B；填空题为最终结果；解答题给出最终结论",',
-    '  "answerKey": "单选题的正确选项字母；多选题为按字母升序拼接的字符串，例如 \\"ABD\\"；其他题型为空字符串",',
+    '  "answerKey": "单选、完形、阅读只填一个正确选项字母；多选按字母升序拼接，例如 ABD；非选择题留空",',
     '  "explanation": "完整解析（Markdown + LaTeX），必须含关键思路、推导步骤、核心知识点与易错点",',
     '  "knowledge": ["知识点标签", "..."],',
     '  "syllabusCheck": "一句话说明本题对应大纲的哪一部分"',
@@ -337,17 +377,14 @@ export function structuralProblems(candidate, allowedTypes) {
   if (!candidate.explanation || candidate.explanation.length < 20) problems.push('解析缺失或过短（缺少必要推导）')
   if (!allowedTypes.includes(candidate.type)) problems.push(`题型 ${candidate.type} 不在本科目允许范围内`)
   if (CHOICE_TYPES.has(candidate.type)) {
-    if (candidate.options.length < 2) problems.push('选择题至少需要 2 个选项')
-    const keys = candidate.options.map((option) => option.key)
-    if (new Set(keys).size !== keys.length) problems.push('选项字母重复')
-    if (candidate.type === 'single') {
-      if (candidate.answerKey.length !== 1) problems.push('单项选择题必须有且仅有一个正确选项')
-      else if (!keys.includes(candidate.answerKey)) problems.push('正确选项不在选项列表中')
-    } else if (!candidate.answerKey) {
-      problems.push('多项选择题必须写明正确选项集合')
+    if (!hasChoiceOptions(candidate.options)) problems.push('选择题至少需要两个有效选项，选项字母须为 A–H 且不可重复')
+    if (!validChoiceKey(candidate.type, candidate.answerKey, candidate.options)) {
+      problems.push(candidate.type === 'multiple'
+        ? '多项选择题必须写明正确选项集合，字母不可重复且必须属于本题选项'
+        : '单选、完形和阅读必须有且仅有一个有效的正确选项')
+    } else if ([...candidate.answerKey].sort().join('') !== candidate.answerKey) {
+      problems.push('多选题正确选项必须按字母升序排列')
     }
-    const sorted = candidate.answerKey.split('').sort()
-    if (sorted.join('') !== candidate.answerKey) problems.push('多选题正确选项必须按字母升序排列')
   }
   return problems
 }
@@ -401,7 +438,7 @@ export async function reviseAnswer({ ctx, subject, examInfo, question, currentAn
       '输出字段（严格 JSON）：',
       '{',
       '  "answer": "标准答案（Markdown）",',
-      '  "answerKey": "选择题的正确选项字母（多选按字母升序），非选择题为空字符串",',
+      '  "answerKey": "单选、完形、阅读只填一个正确选项字母；多选按字母升序；非选择题留空",',
       '  "explanation": "完整解析（Markdown + LaTeX）"',
       '}',
     ].filter(Boolean).join('\n')

package/lib/generation-history.js

@@ -48,6 +48,14 @@ function outlineTopics(subject,references) {
     .filter(label=>label.length>=2&&label.length<=80&&!administrative.test(label)&&!/考试大纲|^20\d{2}/.test(label)&&!typeLabels.has(label)).slice(0,40)
 }
 
+export function rankQuestionTypes(subject, history, preferredType) {
+  const counts = new Map(subject.types.map((type) => [type,0]))
+  for (const question of recentFirst(history).slice(0,WINDOW)) {
+    if (counts.has(question.type)) counts.set(question.type,counts.get(question.type)+1)
+  }
+  return [...subject.types].sort((a,b) => Number(b===preferredType)-Number(a===preferredType) || counts.get(a)-counts.get(b))
+}
+
 export function generationPlan({subject,references,history=[],preferredType}) {
   const recent=recentFirst(history).slice(0,WINDOW),typeCounts=Object.fromEntries(subject.types.map(type=>[type,0])),knowledgeCounts=Object.create(null)
   for(const q of recent) {