daily-question 1.1.0 → 2.1.0

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, 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 { 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…）和用户自填的文字
  * 都允许，只做去空、去重、限长限量。
@@ -62,21 +71,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,9 +142,11 @@ export class DailyQuestionService {
   }
 
   async bootstrap() {
-    const today = todayISO()
-    const options = yearOptions(today)
+    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)
     // 旧设置可能落在窗口外（它的初试早已结束）：自动收敛到可选的最早一年
     if (!options.includes(data.settings.targetYear)) {
       await this.store.update((draft) => {
@@ -112,12 +167,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,6 +198,9 @@ 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
@@ -164,27 +225,36 @@ export class DailyQuestionService {
 
   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 enabled=new Set(data.settings.subjects)
+    for(const id of enabled)result[id]={all:0,favorite:0,wrong:0}
+    for(const question of Object.values(data.questions)) {
+      if(!enabled.has(question.subjectId))continue
+      const count=result[question.subjectId]
+      count.all++
+      if(question.favoriteAt)count.favorite++
+      if(this.isWrong(question,this.attemptsOf(data,question.id)))count.wrong++
     }
     return result
   }
 
   isWrong(question, attempts) {
     if (question.wrongBookRemoved) return false
-    const own = attempts.filter((attempt) => attempt.questionId === question.id)
-    return own.some((attempt) => attempt.result === 'wrong')
+    if (question.wrongBookAdded) return true
+    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)||[]
   }
 
   /* ------------------------------ 设置 ------------------------------ */
@@ -193,6 +263,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) => ({
@@ -202,11 +275,14 @@ 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) {
         const year = Math.trunc(Number(patch.targetYear))
-        const allowed = yearOptions()
+        const allowed = yearOptions(todayISO(), draft.examDates)
         if (!Number.isFinite(year) || !allowed.includes(year)) {
           throw new Error(`考研年份只能选 ${allowed[0]}、${allowed[1]}、${allowed[2]}（初试已结束的年份不再提供）`)
         }
@@ -268,14 +344,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)
@@ -283,7 +360,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('题库中没有符合该科目要求的可用题目：请先导入题库，或把该科目的出题来源切换为在线出题')
         }
@@ -293,6 +370,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()
@@ -304,7 +383,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',
@@ -337,6 +418,9 @@ export class DailyQuestionService {
       }
 
       await this.store.update((draft) => {
+        signal?.throwIfAborted()
+        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]
@@ -344,6 +428,7 @@ 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}`
@@ -371,17 +456,17 @@ export class DailyQuestionService {
     }
     if (!candidates.length) return null
     candidates.sort((a, b) => String(a.lastAssignedDate).localeCompare(String(b.lastAssignedDate)))
-    const fresh = candidates.filter((candidate) => candidate.lastAssignedDate !== date)
-    const pool = fresh.length ? fresh : candidates
+    const pool = candidates.filter((candidate) => candidate.lastAssignedDate === candidates[0].lastAssignedDate)
     const chosen = pool[Math.floor(Math.random() * pool.length)]
     const repeated = Boolean(chosen.lastAssignedDate)
     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()
       const existing = draft.questions[qid]
       if (existing) {
         existing.assignedCount = (existing.assignedCount || 1) + 1
@@ -454,10 +539,12 @@ 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
     return {
       id: question.id,
@@ -471,8 +558,17 @@ export class DailyQuestionService {
       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.assignedDate,
+      practiceDate:isToday?date:null,
+      todayAttemptCount:isToday?currentAttempts.length:0,
       createdAt: question.createdAt,
       assignedCount: question.assignedCount || 1,
       repeated: Boolean(question.repeated),
@@ -485,6 +581,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,
@@ -540,6 +637,7 @@ export class DailyQuestionService {
       type: question.type,
       typeLabel: QUESTION_TYPE_LABEL[question.type] || question.type,
       summary: summariseStem(question.stem),
+      stem: question.stem,
       assignedDate: question.assignedDate,
       attemptCount: attempts.length,
       favorite: Boolean(question.favoriteAt),
@@ -551,9 +649,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,12 +667,16 @@ export class DailyQuestionService {
       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)))
+      || 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)),
     }
   }
 
@@ -581,7 +685,9 @@ export class DailyQuestionService {
     const question = data.questions[qid]
     if (!question) throw new Error('题目不存在（可能已随题库删除而失效）')
     const thread = this.threadView(data, qid)
-    return { ok: true, question: this.questionView(data, question), thread }
+    const date=todayISO()
+    const isToday = data.daily[`${date}|${question.subjectId}`]?.questionId === qid
+    return { ok: true, question: this.questionView(data, question, {date}), thread, isToday }
   }
 
   threadView(data, qid) {
@@ -600,12 +706,6 @@ export class DailyQuestionService {
     const data = await this.data()
     const question = data.questions[qid]
     if (!question) throw new Error('题目不存在')
-    if (attemptId) {
-      const existing = data.attempts.find((attempt) => attempt.id === attemptId)
-      if (existing) {
-        return { ok: true, question: this.questionView(await this.data(), question), duplicated: true }
-      }
-    }
     const isChoice = CHOICE_TYPES.has(question.type)
     let result = 'pending'
     let normalizedChoice = ''
@@ -613,7 +713,9 @@ export class DailyQuestionService {
       if (!isChoice) throw new Error('主观题不支持提交选项')
       normalizedChoice = normalizeChoice(choice, question)
       const key = sortLetters(question.currentAnswer?.answerKey)
-      result = key && normalizedChoice === key ? 'correct' : 'wrong'
+      const canGrade = key && key.split('').every((letter) => question.options?.some((option) => option.key === letter))
+        && (question.type !== 'single' || key.length === 1)
+      result = canGrade ? (normalizedChoice === key ? 'correct' : 'wrong') : 'pending'
     } else if (mode === 'giveup') {
       result = 'wrong'
     } else if (mode === 'done') {
@@ -627,42 +729,53 @@ export class DailyQuestionService {
       id: attemptId || randomUUID(),
       questionId: qid,
       at: stamp,
+      practiceDate:todayISO(new Date(stamp)),
       type: question.type,
       mode,
       choice: normalizedChoice,
       result,
       revealedAt: stamp,
-      judgedAt: mode === 'done' ? null : stamp,
+      judgedAt: result === 'pending' ? null : stamp,
     }
 
-    await this.store.update((draft) => {
+    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)
+      if (existing) {
+        if (existing.questionId !== qid) throw new Error('作答 ID 已用于其他题目')
+        return true
+      }
       draft.attempts.push(attempt)
       if (target.currentAnswer && !target.currentAnswer.firstShownAt) {
         target.currentAnswer.firstShownAt = stamp
       }
       target.updatedAt = stamp
-      return draft
+      return false
     })
     const fresh = await this.data()
-    return { ok: true, question: this.questionView(fresh, fresh.questions[qid] || question) }
+    return { ok: true, question: this.questionView(fresh, fresh.questions[qid] || question, {attemptId:attempt.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 }) {
@@ -689,9 +802,54 @@ export class DailyQuestionService {
     return { ok: true, question: this.questionView(data, data.questions[qid]), counts: this.counts(data) }
   }
 
+  async bulkQuestions({ qids, action, confirmProtected = false }) {
+    if (!Array.isArray(qids) || !qids.length || qids.some((id) => typeof id !== 'string' || !id)) {
+      throw new Error('请选择需要管理的题目')
+    }
+    if (!['delete', 'favorite', 'unfavorite', 'wrong', 'unwrong'].includes(action)) throw new Error('未知的批量操作')
+    const ids = new Set(qids)
+    const result = await this.store.update((draft) => {
+      const questions = [...ids].map((id) => {
+        if (!Object.hasOwn(draft.questions, id)) throw new Error('部分题目已不存在，请刷新列表后重试')
+        return draft.questions[id]
+      })
+      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 }
+      }
+      const stamp = nowISO()
+      for (const q of questions) {
+        if (action === 'delete') {
+          delete draft.questions[q.id]
+          delete draft.threads[q.id]
+        } else {
+          if (action === 'favorite') q.favoriteAt = stamp
+          if (action === 'unfavorite') q.favoriteAt = null
+          if (action === 'wrong' || action === 'unwrong') {
+            q.wrongBookAdded = action === 'wrong'
+            q.wrongBookRemoved = action === 'unwrong'
+          }
+          q.updatedAt = stamp
+        }
+      }
+      if (action === 'delete') {
+        draft.attempts = draft.attempts.filter((attempt) => !ids.has(attempt.questionId))
+        for (const [key, record] of Object.entries(draft.daily)) {
+          if (ids.has(record.questionId)) delete draft.daily[key]
+        }
+      }
+      return { affected: ids.size }
+    })
+    return { ok: true, ...result, counts: this.counts(await this.data()) }
+  }
+
   /* ------------------------------ 答案修订 ------------------------------ */
 
   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('题目不存在')
@@ -704,6 +862,7 @@ export class DailyQuestionService {
       question,
       currentAnswer: question.currentAnswer,
       reason,
+      signal,
     })
     const candidate = {
       candidateId: `c_${randomUUID().slice(0, 8)}`,
@@ -716,6 +875,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
@@ -778,6 +938,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('追问内容过长，请精简后再发送')
@@ -796,15 +974,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,
@@ -814,17 +997,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(() => {})
     }
@@ -836,6 +1021,7 @@ export class DailyQuestionService {
         answerDetail: question.currentAnswer,
         history: history.filter((item) => item.id !== messageId),
         message: text,
+        signal,
       })
       const assistantMessage = {
         id: randomUUID(),
@@ -847,10 +1033,12 @@ export class DailyQuestionService {
         status: 'sent',
       }
       await this.store.update((draft) => {
-        if (!draft.threads[qid]) draft.threads[qid] = { threadId: qid, questionId: qid, messages: [], updatedAt: nowISO() }
+        signal.throwIfAborted()
+        if (!draft.questions[qid]) throw new Error('题目已删除')
         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
@@ -865,9 +1053,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) }
   }
@@ -881,7 +1074,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 {