daily-question 2.0.0 → 2.1.1

package/lib/service.js

@@ -1,10 +1,13 @@
 import { randomUUID } from 'node:crypto'
-import { findSubject, allSubjects, QUESTION_TYPE_LABEL, CHOICE_TYPES, subjectTypes } from './subjects.js'
+import { findSubject, allSubjects, QUESTION_TYPE_LABEL, CHOICE_TYPES, hasChoiceOptions, validChoiceKey, subjectTypes, REFERENCE_EXAMS } from './subjects.js'
 import { computeCountdown, resolveExamDate, todayISO, verifyExamDateOnline, yearOptions } from './exam-dates.js'
 import { createVerifiedQuestion, QuestionGenerationError, reviseAnswer } from './generate.js'
 import { answerFollowup } from './tutor.js'
-import { parseBankText, extractBankPdf } from './bank.js'
+import { parseBankText, extractBankPdf, isUsableBankItem } from './bank.js'
 import { Store, resolveDataDir } from './store.js'
+import { createUpdateChecker, PLUGIN_VERSION } from './updates.js'
+import { withTimeout } from './async.js'
+import { indexQuestionHistory,findQuestionRepeat } from './generation-history.js'
 
 const MAX_STEM_SUMMARY = 140
 const IMPORT_TTL_MS = 30 * 60 * 1000
@@ -13,6 +16,12 @@ function nowISO() {
   return new Date().toISOString()
 }
 
+function attemptDate(attempt) {
+  if(/^\d{4}-\d{2}-\d{2}$/.test(attempt.practiceDate||''))return attempt.practiceDate
+  const date=new Date(attempt.revealedAt||attempt.at||'')
+  return Number.isFinite(date.getTime())?todayISO(date):''
+}
+
 /**
  * 自定义科目的题型：内置键（single/multiple/fill/solution…）和用户自填的文字
  * 都允许，只做去空、去重、限长限量。
@@ -47,6 +56,8 @@ function normalizeChoice(value, question) {
   for (const letter of upper) {
     if (!keys.includes(letter)) throw new Error(`选项 ${letter} 不在本题选项中`)
   }
+  if (question.type !== 'multiple' && upper.length !== 1) throw new Error('本题只能选择一个选项')
+  if (new Set(upper).size !== upper.length) throw new Error('选项不能重复')
   return upper.split('').sort().join('')
 }
 
@@ -62,21 +73,65 @@ function sortLetters(value) {
  * 后续可能的 Agent 工具共享同一套业务逻辑。
  */
 export class DailyQuestionService {
-  constructor(ctx) {
+  constructor(ctx, { taskTimeoutMs } = {}) {
     this.ctx = ctx
     this.store = new Store(resolveDataDir())
     this.inflightDaily = new Map()
+    this.inflightFollowups = new Map()
+    this.recovery = null
+    this.attemptIndexes = new WeakMap()
+    this.tasks = new Map()
+    this.taskTimeoutMs = taskTimeoutMs
     this.imports = new Map()
+    this.checkUpdates = createUpdateChecker()
     this.log = typeof ctx.logger === 'function' ? ctx.logger('daily-question') : (ctx.logger || console)
   }
 
   async init() {
-    await this.store.load()
+    await this.data()
+  }
+
+  runTask(key, details, run) {
+    if (this.tasks.has(key)) return this.tasks.get(key).promise
+    const job = { ...details, controller: new AbortController() }
+    job.promise = withTimeout(run, { signal: job.controller.signal,
+      timeoutMs: this.taskTimeoutMs ?? (details.kind === 'daily' ? 15*60*1000 : details.kind === 'revise' ? 10*60*1000 : 5*60*1000),
+      message: '任务超时，已停止本次生成，可以重试',
+    }).finally(() => { if (this.tasks.get(key) === job) this.tasks.delete(key) })
+    this.tasks.set(key, job)
+    return job.promise
+  }
+
+  async cancelTask({ kind, subjectId, qid, clientMessageId }) {
+    if (!['daily','revise','followup'].includes(kind)) throw new Error('不支持取消此类任务')
+    const jobs = [...this.tasks.values()].filter((job) => job.kind === kind && (kind === 'daily'
+      ? Boolean(subjectId) && job.subjectId === subjectId
+      : Boolean(qid) && job.qid === qid && (kind !== 'followup' || !clientMessageId || job.clientMessageId === clientMessageId)))
+    for (const job of jobs) job.controller.abort(Object.assign(new Error('任务已取消，可以重试'), { code:'TASK_CANCELLED' }))
+    await Promise.allSettled(jobs.map((job) => job.promise))
+    return { ok: true, cancelled: jobs.length }
+  }
+
+  dispose() {
+    for (const job of this.tasks.values()) job.controller.abort(new Error('插件已停止，本次任务已取消'))
   }
 
   /* ------------------------------ 读取与状态 ------------------------------ */
 
   async data() {
+    if (!this.recovery) {
+      this.recovery = (async () => {
+        const data = await this.store.read()
+        if (Object.values(data.threads).some((thread) => thread.messages?.some((message) => message.status === 'pending'))) {
+          await this.store.update((draft) => {
+            for (const thread of Object.values(draft.threads)) {
+              for (const message of thread.messages || []) if (message.status === 'pending') message.status = 'failed'
+            }
+          })
+        }
+      })().catch((error) => { this.recovery = null; throw error })
+    }
+    await this.recovery
     return this.store.read()
   }
 
@@ -89,7 +144,9 @@ export class DailyQuestionService {
   }
 
   async bootstrap() {
-    const today = todayISO()
+    const now = new Date()
+    const today = todayISO(now)
+    const nextDayAt = new Date(now.getFullYear(), now.getMonth(), now.getDate() + 1).toISOString()
     let data = await this.data()
     const options = yearOptions(today, data.examDates)
     // 旧设置可能落在窗口外（它的初试早已结束）：自动收敛到可选的最早一年
@@ -112,12 +169,15 @@ export class DailyQuestionService {
     return {
       ok: true,
       dataFile: this.store.file,
+      pluginVersion: PLUGIN_VERSION,
       dataError: this.store.lastError,
       today,
-      now: nowISO(),
+      now: now.toISOString(),
+      nextDayAt,
       yearOptions: options,
       settings: data.settings,
       customSubjects: data.customSubjects,
+      referenceExams: REFERENCE_EXAMS,
       examInfo,
       countdown,
       subjects: this.subjectViews(data),
@@ -140,10 +200,13 @@ export class DailyQuestionService {
         types: subject.types,
         typeLabels: subject.types.map((type) => QUESTION_TYPE_LABEL[type] || type),
         custom: Boolean(subject.custom),
+        referenceSubjectId: subject.referenceSubjectId || '',
+        referenceExamName: subject.referenceExamName || '',
+        referenceExamCode: subject.referenceExamCode || '',
         enabled: enabled.has(subject.id),
         source: data.settings.subjectSource[subject.id] || 'auto',
         bankItemCount: usableBanks.reduce((total, bank) => total
-          + bank.items.filter((item) => item.stem && (!item.type || allowed.has(item.type))).length, 0),
+          + bank.items.filter((item) => isUsableBankItem(item) && (!item.type || allowed.has(item.type))).length, 0),
       }
     })
   }
@@ -157,35 +220,42 @@ export class DailyQuestionService {
       subjectId: bank.subjectId || '',
       importedAt: bank.importedAt,
       itemCount: bank.items.length,
-      usable: bank.items.filter((item) => item.stem).length,
+      usable: bank.items.filter(isUsableBankItem).length,
       pendingAnswers: bank.items.filter((item) => item.answerStatus !== 'verified').length,
     }))
   }
 
   counts(data) {
-    const result = {}
-    for (const subjectId of data.settings.subjects) {
-      const questions = Object.values(data.questions).filter((question) => question.subjectId === subjectId)
-      const ids = new Set(questions.map((question) => question.id))
-      const attempts = data.attempts.filter((attempt) => ids.has(attempt.questionId))
-      result[subjectId] = {
-        all: questions.length,
-        favorite: questions.filter((question) => question.favoriteAt).length,
-        wrong: questions.filter((question) => this.isWrong(question, attempts)).length,
-      }
+    const result = Object.create(null)
+    for (const id of data.settings.subjects) result[id] = { all: 0, favorite: 0, wrong: 0 }
+    for(const question of Object.values(data.questions)) {
+      if (!question.subjectId) continue
+      const count = result[question.subjectId] ??= { all: 0, favorite: 0, wrong: 0 }
+      count.all++
+      if(question.favoriteAt)count.favorite++
+      if(this.isWrong(question,this.attemptsOf(data,question.id)))count.wrong++
     }
-    return result
+    return { ...result }
   }
 
   isWrong(question, attempts) {
     if (question.wrongBookRemoved) return false
     if (question.wrongBookAdded) return true
-    const own = attempts.filter((attempt) => attempt.questionId === question.id)
-    return own.some((attempt) => attempt.result === 'wrong')
+    return attempts.some((attempt) => attempt.questionId === question.id && attempt.result === 'wrong')
   }
 
   attemptsOf(data, qid) {
-    return data.attempts.filter((attempt) => attempt.questionId === qid)
+    let index=this.attemptIndexes.get(data)
+    if(!index||index.source!==data.attempts||index.length!==data.attempts.length) {
+      const byQuestion=new Map()
+      for(const attempt of data.attempts) {
+        if(!byQuestion.has(attempt.questionId))byQuestion.set(attempt.questionId,[])
+        byQuestion.get(attempt.questionId).push(attempt)
+      }
+      index={source:data.attempts,length:data.attempts.length,byQuestion}
+      this.attemptIndexes.set(data,index)
+    }
+    return index.byQuestion.get(qid)||[]
   }
 
   /* ------------------------------ 设置 ------------------------------ */
@@ -194,6 +264,9 @@ export class DailyQuestionService {
     const data = await this.store.update((draft) => {
       // 先落自定义科目，后面的 enabled 校验才能识别到它们。
       if (Array.isArray(patch.customSubjects)) {
+        if (patch.customSubjects.some((item) => item?.referenceSubjectId === 'independent' && !(typeof item.referenceExamName === 'string' && item.referenceExamName.trim()))) {
+          throw new Error('独立参考考试请填写准确的考试名称（院校自命题请包含院校名称）')
+        }
         draft.customSubjects = patch.customSubjects
           .filter((item) => item && typeof item.id === 'string' && typeof item.name === 'string')
           .map((item) => ({
@@ -203,6 +276,9 @@ export class DailyQuestionService {
             types: normalizeCustomTypes(item.types),
             outline: Array.isArray(item.outline) ? item.outline.filter((line) => typeof line === 'string').slice(0, 20) : [],
             guidance: typeof item.guidance === 'string' ? item.guidance : '',
+            referenceSubjectId: ['independent','auto'].includes(item.referenceSubjectId) ? item.referenceSubjectId : REFERENCE_EXAMS.find((exam) => exam.id === item.referenceSubjectId)?.id || '',
+            referenceExamName: typeof item.referenceExamName === 'string' ? item.referenceExamName.trim().slice(0,100) : '',
+            referenceExamCode: typeof item.referenceExamCode === 'string' ? item.referenceExamCode.trim().slice(0,20) : '',
           }))
       }
       if (patch.targetYear !== undefined) {
@@ -269,14 +345,15 @@ export class DailyQuestionService {
       return { ok: true, question: this.questionView(fresh, fresh.questions[result.questionId]), thread: this.threadView(fresh, result.questionId), created: result.created }
     }
 
-    const task = this.createDaily(subject, date, key).finally(() => this.inflightDaily.delete(key))
+    const task = this.runTask('daily:'+key, {kind:'daily',subjectId:subject.id},
+      (signal) => this.createDaily(subject, date, key, signal)).finally(() => this.inflightDaily.delete(key))
     this.inflightDaily.set(key, task)
     const result = await task
     const fresh = await this.data()
     return { ok: true, question: this.questionView(fresh, fresh.questions[result.questionId]), thread: this.threadView(fresh, result.questionId), created: result.created }
   }
 
-  async createDaily(subject, date, key) {
+  async createDaily(subject, date, key, signal) {
     const data = await this.data()
     const source = data.settings.subjectSource[subject.id] || 'auto'
     const examInfo = resolveExamDate(data.settings.targetYear, data.examDates)
@@ -284,7 +361,7 @@ export class DailyQuestionService {
     try {
       if (source !== 'online') {
         const picked = this.pickFromBank(data, subject, date)
-        if (picked) return await this.publishBankQuestion(picked, subject, date, key)
+        if (picked) return await this.publishBankQuestion(picked, subject, date, key, signal)
         if (source === 'bank') {
           throw new Error('题库中没有符合该科目要求的可用题目：请先导入题库，或把该科目的出题来源切换为在线出题')
         }
@@ -294,6 +371,8 @@ export class DailyQuestionService {
         ctx: this.ctx,
         subject,
         examInfo,
+        signal,
+        history:Object.values(data.questions).filter(question=>question.subjectId===subject.id),
       })
       const qid = `q_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`
       const stamp = nowISO()
@@ -305,7 +384,9 @@ export class DailyQuestionService {
         stem: generated.stem,
         options: generated.options,
         knowledge: generated.knowledge,
+        coverageTopic:generated.coverageTopic,
         difficulty: generated.difficulty,
+        examAlignment: generated.examAlignment,
         syllabusCheck: generated.syllabusCheck || '',
         source: {
           kind: 'online',
@@ -338,6 +419,10 @@ export class DailyQuestionService {
       }
 
       await this.store.update((draft) => {
+        signal?.throwIfAborted()
+        if (!draft.settings.subjects.includes(subject.id)) throw new Error('该科目已停用')
+        const history=Object.values(draft.questions).filter(question=>question.subjectId===subject.id)
+        if(findQuestionRepeat(generated,indexQuestionHistory(history)))throw new Error('题目与已发布题目重复，已阻止发布，请重试生成新题')
         draft.questions[qid] = record
         draft.daily[key] = { date, subjectId: subject.id, questionId: qid, status: 'ready', createdAt: stamp }
         delete draft.failures[subject.id]
@@ -345,12 +430,12 @@ export class DailyQuestionService {
       })
       return { questionId: qid, created: true }
     } catch (error) {
+      if (signal?.aborted) throw signal.reason
       const message = error instanceof QuestionGenerationError
         ? error.message
         : `在线出题失败：${error?.message || error}`
       await this.store.update((draft) => {
-        draft.failures[subject.id] = { at: nowISO(), message }
-        return draft
+        if (draft.settings.subjects.includes(subject.id)) draft.failures[subject.id] = { at: nowISO(), message }
       }).catch(() => {})
       throw new Error(message)
     }
@@ -362,7 +447,7 @@ export class DailyQuestionService {
     for (const bank of data.banks) {
       if (bank.subjectId && bank.subjectId !== subject.id) continue
       for (const item of bank.items) {
-        if (!item.stem) continue
+        if (!isUsableBankItem(item)) continue
         const qid = bankQuestionId(bank.id, item.id)
         const existing = data.questions[qid]
         if (existing && existing.subjectId !== subject.id) continue
@@ -378,10 +463,12 @@ export class DailyQuestionService {
     return { ...chosen, repeated }
   }
 
-  async publishBankQuestion(picked, subject, date, key) {
+  async publishBankQuestion(picked, subject, date, key, signal) {
     const { bank, item, qid, repeated } = picked
     const stamp = nowISO()
     await this.store.update((draft) => {
+      signal?.throwIfAborted()
+      if (!draft.settings.subjects.includes(subject.id)) throw new Error('该科目已停用')
       const existing = draft.questions[qid]
       if (existing) {
         existing.assignedCount = (existing.assignedCount || 1) + 1
@@ -454,11 +541,15 @@ export class DailyQuestionService {
 
   /* ------------------------------ 题目视图 ------------------------------ */
 
-  questionView(data, question) {
+  questionView(data, question, { attemptId, date = todayISO() } = {}) {
     const attempts = this.attemptsOf(data, question.id)
-    const revealed = attempts.length > 0
-    const last = attempts[attempts.length - 1] || null
+    const isToday=data.daily[`${date}|${question.subjectId}`]?.questionId===question.id
+    const currentAttempts=isToday?attempts.filter(attempt=>attemptDate(attempt)===date):attempts
+    const revealed = currentAttempts.length > 0
+    const last = (attemptId ? currentAttempts.find((attempt) => attempt.id === attemptId) : currentAttempts[currentAttempts.length - 1]) || null
     const answer = question.currentAnswer
+    const isChoice = CHOICE_TYPES.has(question.type)
+    const canSelect = isChoice && hasChoiceOptions(question.options)
     return {
       id: question.id,
       subjectId: question.subjectId,
@@ -466,13 +557,23 @@ export class DailyQuestionService {
       type: question.type,
       typeLabel: QUESTION_TYPE_LABEL[question.type] || question.type,
       /** 完形填空 / 阅读理解按选择题判分，前端据此渲染选项而不是“作答完毕”。 */
-      isChoice: CHOICE_TYPES.has(question.type),
+      isChoice,
+      canSelect,
       stem: question.stem,
       options: question.options || [],
       knowledge: question.knowledge || [],
       difficulty: question.difficulty || 3,
+      examAlignment: question.examAlignment ? {
+        ...question.examAlignment,
+        rationale: revealed ? question.examAlignment.rationale : '',
+        warnings: revealed ? question.examAlignment.warnings || [] : [],
+        outlineEvidence: revealed ? question.examAlignment.outlineEvidence : [],
+        paperEvidence: revealed ? question.examAlignment.paperEvidence : [],
+      } : null,
       source: question.source,
-      assignedDate: question.assignedDate,
+      assignedDate: isToday ? date : question.lastAssignedDate || question.assignedDate,
+      practiceDate:isToday?date:null,
+      todayAttemptCount:isToday?currentAttempts.length:0,
       createdAt: question.createdAt,
       assignedCount: question.assignedCount || 1,
       repeated: Boolean(question.repeated),
@@ -485,6 +586,7 @@ export class DailyQuestionService {
         mode: attempt.mode,
         choice: attempt.choice || '',
         judgedAt: attempt.judgedAt || null,
+        practiceDate:attemptDate(attempt),
       })),
       attemptCount: attempts.length,
       lastAttempt: last ? { id: last.id, at: last.at, result: last.result, mode: last.mode, choice: last.choice || '' } : null,
@@ -505,7 +607,7 @@ export class DailyQuestionService {
         ? {
           versionId: answer.versionId,
           answer: answer.answer,
-          answerKey: answer.answerKey || '',
+          answerKey: canSelect && validChoiceKey(question.type, answer.answerKey, question.options) ? answer.answerKey : '',
           explanation: answer.explanation,
           verified: Boolean(answer.verified),
           basis: answer.basis,
@@ -541,7 +643,7 @@ export class DailyQuestionService {
       typeLabel: QUESTION_TYPE_LABEL[question.type] || question.type,
       summary: summariseStem(question.stem),
       stem: question.stem,
-      assignedDate: question.assignedDate,
+      assignedDate: question.lastAssignedDate || question.assignedDate,
       attemptCount: attempts.length,
       favorite: Boolean(question.favoriteAt),
       wrongEver: this.isWrong(question, attempts),
@@ -552,9 +654,11 @@ export class DailyQuestionService {
     }
   }
 
-  async listQuestions({ subjectId, kind = 'all' } = {}) {
+  async listQuestions({ subjectId, kind = 'all', page = 1, pageSize = 50, idsOnly = false } = {}) {
     const data = await this.data()
     if (!subjectId) throw new Error('缺少科目')
+    if(!['all','favorite','wrong','today'].includes(kind))throw new Error('未知题目栏目')
+    if(!Number.isInteger(page)||page<1||!Number.isInteger(pageSize)||pageSize<1||pageSize>100)throw new Error('分页参数无效，每页最多100道题')
     let questions = Object.values(data.questions).filter((question) => question.subjectId === subjectId)
     if (kind === 'favorite') questions = questions.filter((question) => question.favoriteAt)
     if (kind === 'wrong') {
@@ -567,23 +671,28 @@ export class DailyQuestionService {
       const record = data.daily[`${todayISO()}|${subjectId}`]
       questions = questions.filter((question) => question.id === record?.questionId)
     }
-    questions.sort((a, b) => String(b.assignedDate).localeCompare(String(a.assignedDate))
-      || String(b.createdAt).localeCompare(String(a.createdAt)))
+    questions.sort((a, b) => String(b.lastAssignedDate || b.assignedDate).localeCompare(String(a.lastAssignedDate || a.assignedDate))
+      || String(b.createdAt).localeCompare(String(a.createdAt)) || String(b.id).localeCompare(String(a.id)))
+    const total=questions.length,totalPages=Math.max(1,Math.ceil(total/pageSize))
+    if(idsOnly===true)return {ok:true,kind,subjectId,total,ids:questions.map(q=>q.id)}
+    page=Math.min(page,totalPages)
     return {
       ok: true,
       kind,
       subjectId,
-      items: questions.map((question) => this.summaryView(data, question)),
+      total,page,pageSize,totalPages,
+      items: questions.slice((page-1)*pageSize,page*pageSize).map((question) => this.summaryView(data, question)),
     }
   }
 
-  async getQuestion({ qid }) {
+  async getQuestion({ qid, attemptId }) {
     const data = await this.data()
     const question = data.questions[qid]
     if (!question) throw new Error('题目不存在（可能已随题库删除而失效）')
     const thread = this.threadView(data, qid)
-    const isToday = data.daily[`${todayISO()}|${question.subjectId}`]?.questionId === qid
-    return { ok: true, question: this.questionView(data, question), thread, isToday }
+    const date=todayISO()
+    const isToday = data.daily[`${date}|${question.subjectId}`]?.questionId === qid
+    return { ok: true, question: this.questionView(data, question, { date, attemptId }), thread, isToday }
   }
 
   threadView(data, qid) {
@@ -599,71 +708,67 @@ export class DailyQuestionService {
   /* ------------------------------ 作答 ------------------------------ */
 
   async reveal({ qid, mode = 'submit', choice = '', attemptId }) {
-    const data = await this.data()
-    const question = data.questions[qid]
-    if (!question) throw new Error('题目不存在')
-    const isChoice = CHOICE_TYPES.has(question.type)
-    let result = 'pending'
-    let normalizedChoice = ''
-    if (mode === 'submit') {
-      if (!isChoice) throw new Error('主观题不支持提交选项')
-      normalizedChoice = normalizeChoice(choice, question)
-      const key = sortLetters(question.currentAnswer?.answerKey)
-      result = key && normalizedChoice === key ? 'correct' : 'wrong'
-    } else if (mode === 'giveup') {
-      result = 'wrong'
-    } else if (mode === 'done') {
-      result = 'pending'
-    } else {
-      throw new Error(`未知的作答方式：${mode}`)
-    }
-
-    const stamp = nowISO()
-    const attempt = {
-      id: attemptId || randomUUID(),
-      questionId: qid,
-      at: stamp,
-      type: question.type,
-      mode,
-      choice: normalizedChoice,
-      result,
-      revealedAt: stamp,
-      judgedAt: mode === 'done' ? null : stamp,
-    }
-
+    const id = attemptId || randomUUID()
     const duplicated = await this.store.update((draft) => {
-      const target = draft.questions[qid]
-      if (!target) throw new Error('题目不存在')
-      const existing = draft.attempts.find((item) => item.id === attempt.id)
+      const question = draft.questions[qid]
+      if (!question) throw new Error('题目不存在')
+      const existing = draft.attempts.find((item) => item.id === id)
       if (existing) {
         if (existing.questionId !== qid) throw new Error('作答 ID 已用于其他题目')
+        if (existing.mode !== mode || (existing.choice || '') !== (mode === 'submit' ? sortLetters(choice) : '')) {
+          throw Object.assign(new Error('本轮已保存另一份作答，请查看已保存的结果'), { code: 'ATTEMPT_CONFLICT' })
+        }
         return true
       }
-      draft.attempts.push(attempt)
-      if (target.currentAnswer && !target.currentAnswer.firstShownAt) {
-        target.currentAnswer.firstShownAt = stamp
+      let result = 'pending'
+      let normalizedChoice = ''
+      if (mode === 'submit') {
+        if (!CHOICE_TYPES.has(question.type)) throw new Error('主观题不支持提交选项')
+        if (!hasChoiceOptions(question.options)) throw new Error('选项不完整，请使用“作答完毕”查看答案')
+        normalizedChoice = normalizeChoice(choice, question)
+        const key = question.currentAnswer?.answerKey
+        if (validChoiceKey(question.type, key, question.options)) result = normalizedChoice === sortLetters(key) ? 'correct' : 'wrong'
+      } else if (mode === 'giveup') {
+        result = 'wrong'
+      } else if (mode !== 'done') {
+        throw new Error(`未知的作答方式：${mode}`)
+      }
+      const stamp = nowISO()
+      draft.attempts.push({
+        id, questionId: qid, at: stamp, practiceDate: todayISO(new Date(stamp)),
+        type: question.type, mode, choice: normalizedChoice, result,
+        revealedAt: stamp, judgedAt: result === 'pending' ? null : stamp,
+      })
+      if (question.currentAnswer && !question.currentAnswer.firstShownAt) {
+        question.currentAnswer.firstShownAt = stamp
       }
-      target.updatedAt = stamp
+      question.updatedAt = stamp
       return false
     })
     const fresh = await this.data()
-    return { ok: true, question: this.questionView(fresh, fresh.questions[qid] || question), duplicated }
+    if (!fresh.questions[qid]) throw new Error('题目已删除')
+    return { ok: true, question: this.questionView(fresh, fresh.questions[qid], { attemptId: id }), duplicated }
   }
 
-  async judge({ qid, verdict }) {
+  async judge({ qid, verdict, attemptId }) {
     if (!['correct', 'wrong'].includes(verdict)) throw new Error('判定结果不合法')
-    await this.store.update((draft) => {
-      const attempts = draft.attempts.filter((attempt) => attempt.questionId === qid)
-      const target = [...attempts].reverse().find((attempt) => attempt.result === 'pending' && !attempt.judgedAt)
-      if (!target) throw new Error('当前没有待判定的作答')
+    if (typeof attemptId !== 'string' || !attemptId) throw new Error('缺少本次作答ID，请重新打开题目后判定')
+    const duplicated=await this.store.update((draft) => {
+      if (!draft.questions[qid]) throw new Error('题目不存在')
+      const target = draft.attempts.find((attempt) => attempt.id === attemptId && attempt.questionId === qid)
+      if (!target) throw new Error('本次作答不存在或不属于这道题')
+      if (target.result !== 'pending' || target.judgedAt) {
+        if (target.result === verdict && target.judgedAt) return true
+        throw new Error('本次作答已判定，不能覆盖或改判其他作答')
+      }
       target.result = verdict
       target.judgedAt = nowISO()
       const question = draft.questions[qid]
       if (question) question.updatedAt = nowISO()
-      return draft
+      return false
     })
     const data = await this.data()
-    return { ok: true, question: this.questionView(data, data.questions[qid]) }
+    return { ok: true, question: this.questionView(data, data.questions[qid], {attemptId}), duplicated }
   }
 
   async favorite({ qid, value }) {
@@ -701,7 +806,7 @@ export class DailyQuestionService {
         if (!Object.hasOwn(draft.questions, id)) throw new Error('部分题目已不存在，请刷新列表后重试')
         return draft.questions[id]
       })
-      const protectedCount = questions.filter((q) => q.favoriteAt || this.isWrong(q, draft.attempts)).length
+      const protectedCount = questions.filter((q) => q.favoriteAt || this.isWrong(q, this.attemptsOf(draft,q.id))).length
       if (action === 'delete' && protectedCount && confirmProtected !== true) {
         return { requiresConfirmation: true, protectedCount }
       }
@@ -734,6 +839,10 @@ export class DailyQuestionService {
   /* ------------------------------ 答案修订 ------------------------------ */
 
   async revise({ qid, reason = '' }) {
+    return this.runTask('revise:'+qid, {kind:'revise',qid}, (signal) => this.createRevision({qid,reason}, signal))
+  }
+
+  async createRevision({ qid, reason }, signal) {
     const data = await this.data()
     const question = data.questions[qid]
     if (!question) throw new Error('题目不存在')
@@ -746,6 +855,7 @@ export class DailyQuestionService {
       question,
       currentAnswer: question.currentAnswer,
       reason,
+      signal,
     })
     const candidate = {
       candidateId: `c_${randomUUID().slice(0, 8)}`,
@@ -758,6 +868,7 @@ export class DailyQuestionService {
     }
     await this.store.update((draft) => {
       const target = draft.questions[qid]
+      signal.throwIfAborted()
       if (!target) throw new Error('题目不存在')
       target.pendingRevision = candidate
       return draft
@@ -820,6 +931,24 @@ export class DailyQuestionService {
   /* ------------------------------ 追问 ------------------------------ */
 
   async followup({ qid, message, clientMessageId }) {
+    const messageId = clientMessageId || randomUUID()
+    const key = JSON.stringify([qid, messageId])
+    if (this.inflightFollowups.has(key)) return this.inflightFollowups.get(key)
+    const executionId = randomUUID()
+    const task = this.runTask('followup:'+key, {kind:'followup',qid,clientMessageId:messageId},
+      (signal) => this.createFollowup({ qid, message, clientMessageId: messageId, executionId }, signal))
+      .catch(async (error) => {
+        await this.store.update((draft) => {
+          const target = draft.threads[qid]?.messages.find((item) => item.id === messageId)
+          if (target?.executionId === executionId && target.status === 'pending') target.status = 'failed'
+        }).catch(() => {})
+        throw error
+      }).finally(() => this.inflightFollowups.delete(key))
+    this.inflightFollowups.set(key, task)
+    return task
+  }
+
+  async createFollowup({ qid, message, clientMessageId, executionId }, signal) {
     const text = String(message || '').trim()
     if (!text) throw new Error('追问内容不能为空')
     if (text.length > 4000) throw new Error('追问内容过长，请精简后再发送')
@@ -838,16 +967,20 @@ export class DailyQuestionService {
     const messageId = failed ? failed.id : (clientMessageId || randomUUID())
 
     // 先落盘用户消息：即使回复失败，用户输入也不会丢，并且可以按同一 id 重试。
-    await this.store.update((draft) => {
+    const queued = await this.store.update((draft) => {
+      signal.throwIfAborted()
       if (!draft.questions[qid]) throw new Error('题目已删除')
       if (!draft.threads[qid]) {
-        draft.threads[qid] = { threadId: qid, questionId: qid, messages: [], updatedAt: stamp }
+        draft.threads[qid] = { threadId: qid, questionId: qid, generation: randomUUID(), messages: [], updatedAt: stamp }
       }
       const thread = draft.threads[qid]
+      if (!thread.generation) thread.generation = randomUUID()
       const target = thread.messages.find((item) => item.id === messageId)
       if (target) {
+        if (target.status !== 'failed') return { duplicated: true, generation: thread.generation }
         target.text = text
         target.status = 'pending'
+        target.executionId = executionId
       } else {
         thread.messages.push({
           id: messageId,
@@ -857,17 +990,19 @@ export class DailyQuestionService {
           text,
           createdAt: stamp,
           status: 'pending',
+          executionId,
         })
       }
       thread.updatedAt = stamp
-      return draft
+      return { duplicated: false, generation: thread.generation }
     })
+    if (queued.duplicated) return { ok: true, thread: this.threadView(await this.data(), qid), duplicated: true }
 
     const history = (await this.data()).threads[qid]?.messages || []
     const setStatus = async (status) => {
       await this.store.update((draft) => {
         const target = draft.threads[qid]?.messages.find((item) => item.id === messageId)
-        if (target) target.status = status
+        if (target?.executionId === executionId) target.status = status
         return draft
       }).catch(() => {})
     }
@@ -879,6 +1014,7 @@ export class DailyQuestionService {
         answerDetail: question.currentAnswer,
         history: history.filter((item) => item.id !== messageId),
         message: text,
+        signal,
       })
       const assistantMessage = {
         id: randomUUID(),
@@ -890,11 +1026,12 @@ export class DailyQuestionService {
         status: 'sent',
       }
       await this.store.update((draft) => {
+        signal.throwIfAborted()
         if (!draft.questions[qid]) throw new Error('题目已删除')
-        if (!draft.threads[qid]) draft.threads[qid] = { threadId: qid, questionId: qid, messages: [], updatedAt: nowISO() }
         const thread = draft.threads[qid]
-        const target = thread.messages.find((item) => item.id === messageId)
-        if (target) target.status = 'sent'
+        const target = thread?.messages.find((item) => item.id === messageId)
+        if (!thread || thread.generation !== queued.generation || !target || target.executionId !== executionId || target.status !== 'pending') throw new Error('本次追问已清空或失效，已丢弃迟到的回复')
+        target.status = 'sent'
         thread.messages.push(assistantMessage)
         thread.updatedAt = assistantMessage.createdAt
         return draft
@@ -909,9 +1046,14 @@ export class DailyQuestionService {
 
   async clearThread({ qid }) {
     await this.store.update((draft) => {
-      if (draft.threads[qid]) draft.threads[qid].messages = []
+      if (draft.threads[qid]) {
+        draft.threads[qid].messages = []
+        draft.threads[qid].generation = randomUUID()
+        draft.threads[qid].updatedAt = nowISO()
+      }
       return draft
     })
+    await this.cancelTask({kind:'followup',qid})
     const data = await this.data()
     return { ok: true, thread: this.threadView(data, qid) }
   }
@@ -925,7 +1067,7 @@ export class DailyQuestionService {
       if (!base64) throw new Error('缺少 PDF 文件内容')
       const bytes = Buffer.from(String(base64), 'base64')
       if (bytes.length > 40 * 1024 * 1024) throw new Error('PDF 文件过大（上限 40MB）')
-      const extracted = extractBankPdf(bytes, fileName || name || '')
+      const extracted = await extractBankPdf(bytes, fileName || name || '')
       content = extracted.text
       warnings = extracted.warnings
     } else {
@@ -966,12 +1108,13 @@ export class DailyQuestionService {
         knowledge: item.knowledge,
         difficulty: item.difficulty,
         issues: item.issues,
+        usable: isUsableBankItem(item),
         answerStatus: item.answerStatus,
       })),
       stats: {
         total: parsed.items.length,
         withAnswer: parsed.items.filter((item) => item.answer).length,
-        blocked: parsed.items.filter((item) => !item.stem).length,
+        blocked: parsed.items.length - parsed.usable,
       },
     }
   }
@@ -983,10 +1126,14 @@ export class DailyQuestionService {
     }
   }
 
-  async commitBank({ importId, name, subjectId }) {
+  async commitBank({ importId, name, subjectId, excludedIndexes = [] }) {
     const pending = this.imports.get(importId)
     if (!pending) throw new Error('导入结果已过期，请重新选择文件导入')
-    const usable = pending.items.filter((item) => item.stem && item.stem.length >= 4)
+    if (!Array.isArray(excludedIndexes) || excludedIndexes.some((index) => !Number.isInteger(index) || index < 1 || index > pending.items.length)) {
+      throw new Error('导入勾选有误，请重新选择题目')
+    }
+    const excluded = new Set(excludedIndexes)
+    const usable = pending.items.filter((item) => !excluded.has(item.index) && isUsableBankItem(item))
     if (!usable.length) throw new Error('没有可用的题目可以入库：请检查文件结构后重新导入')
     const bankId = `bank_${randomUUID().slice(0, 8)}`
     const bank = {
@@ -1010,11 +1157,13 @@ export class DailyQuestionService {
         answerStatus: item.answer ? 'unverified' : 'missing',
       })),
     }
-    await this.store.update((draft) => {
-      draft.banks.push(bank)
-      return draft
-    })
     this.imports.delete(importId)
+    try {
+      await this.store.update((draft) => { draft.banks.push(bank) })
+    } catch (error) {
+      this.imports.set(importId, pending)
+      throw error
+    }
     const data = await this.data()
     return { ok: true, bank: this.bankViews(data).find((item) => item.id === bankId), banks: this.bankViews(data), subjects: this.subjectViews(data) }
   }
@@ -1091,11 +1240,11 @@ export class DailyQuestionService {
     const kept = Object.values(data.questions).filter((question) => question.subjectId === subjectId).length
     const result = await this.saveSettings({
       subjects: remaining,
-      activeSubject: data.settings.activeSubject === subjectId ? (remaining[0] || null) : data.settings.activeSubject,
+      activeSubject: data.settings.activeSubject === subjectId && !kept ? (remaining[0] || null) : data.settings.activeSubject,
     })
     return {
       ...result,
-      message: `科目已移出每日出题，历史数据保留：${kept} 道题目及其作答记录仍可在“全部”中查看。`,
+      message: `科目已移出每日出题，历史数据保留：${kept} 道题目及其作答记录可通过“已停用科目”查看。`,
     }
   }
 }