@zhouchangui/math-ati 0.1.0

package/server/knowledgeFeedback.js

@@ -0,0 +1,299 @@
+import path from 'node:path';
+import { readFile, writeFile } from 'node:fs/promises';
+import {
+  chapterDataPaths,
+  paths,
+  readJson,
+  syncGlobalIndexes,
+  writeJson
+} from './fileStore.js';
+
+function statusForScore(item) {
+  const maxScore = Number(item.maxScore || 0);
+  const score = Number(item.score || 0);
+  const ratio = maxScore > 0 ? score / maxScore : 0;
+  if (item.status === 'correct' || ratio >= 0.85) return 'mastered';
+  if (item.status === 'partial' || ratio > 0) return 'needs_review';
+  if (item.status === 'wrong' || item.status === 'unrecognized') return 'needs_review';
+  return 'needs_review';
+}
+
+function questionById(practice) {
+  return new Map((practice.questions || []).map((question) => [question.id, question]));
+}
+
+export function gradingStats(grading = []) {
+  const totalScore = grading.reduce((sum, item) => sum + Number(item.maxScore || 0), 0);
+  const earnedScore = grading.reduce((sum, item) => sum + Number(item.score || 0), 0);
+  const accuracy = totalScore > 0 ? Math.round((earnedScore / totalScore) * 100) : 0;
+  const byStatus = grading.reduce((acc, item) => {
+    const key = item.status || 'needs_review';
+    acc[key] = (acc[key] || 0) + 1;
+    return acc;
+  }, {});
+  return {
+    totalQuestions: grading.length,
+    totalScore,
+    earnedScore,
+    accuracy,
+    correct: byStatus.correct || 0,
+    partial: byStatus.partial || 0,
+    wrong: byStatus.wrong || 0,
+    unrecognized: byStatus.unrecognized || 0,
+    needsReview: byStatus.needs_review || 0
+  };
+}
+
+export function buildKnowledgeEvidence({ practice, grading = [], stitchedAnswers = [] }) {
+  const questions = questionById(practice);
+  const stitchedByQuestion = new Map(stitchedAnswers.map((item) => [item.questionId, item]));
+  const evidence = [];
+  for (const item of grading) {
+    const question = questions.get(item.questionId);
+    if (!question) continue;
+    const result = statusForScore(item);
+    for (const knowledgePointId of question.knowledgePointIds || []) {
+      evidence.push({
+        knowledgePointId,
+        knowledgePointTitle: question.knowledgePoints?.[
+          (question.knowledgePointIds || []).indexOf(knowledgePointId)
+        ] || knowledgePointId,
+        sourcePracticeId: practice.id,
+        sourceQuestionId: question.id,
+        sourcePages: stitchedByQuestion.get(question.id)?.sourcePages || item.sourcePages || [],
+        evidenceType: item.status || 'needs_review',
+        result,
+        score: Number(item.score || 0),
+        maxScore: Number(item.maxScore || question.score || 0),
+        confidence: item.confidence || stitchedByQuestion.get(question.id)?.stitchingConfidence || 'medium',
+        reason: item.comment || item.mistakeSummary || ''
+      });
+    }
+  }
+  return evidence;
+}
+
+export function buildWeakPoints({ practice, grading = [], knowledgeEvidence = [] }) {
+  const questions = questionById(practice);
+  const byPoint = new Map();
+  for (const evidence of knowledgeEvidence) {
+    if (evidence.result !== 'needs_review') continue;
+    const current = byPoint.get(evidence.knowledgePointId) || {
+      knowledgePointId: evidence.knowledgePointId,
+      title: evidence.knowledgePointTitle,
+      sourceQuestionIds: [],
+      issueTypes: [],
+      severity: 'low',
+      issue: '',
+      nextAction: ''
+    };
+    current.sourceQuestionIds.push(evidence.sourceQuestionId);
+    const gradingItem = grading.find((item) => item.questionId === evidence.sourceQuestionId);
+    current.issueTypes.push(...(gradingItem?.errorTypes || ['待巩固']));
+    byPoint.set(evidence.knowledgePointId, current);
+  }
+
+  for (const point of byPoint.values()) {
+    point.sourceQuestionIds = [...new Set(point.sourceQuestionIds)].sort((a, b) => {
+      const left = Number(a.replace(/^q/, ''));
+      const right = Number(b.replace(/^q/, ''));
+      return left - right;
+    });
+    point.issueTypes = [...new Set(point.issueTypes.filter(Boolean))].slice(0, 6);
+    const related = point.sourceQuestionIds
+      .map((questionId) => questions.get(questionId))
+      .filter(Boolean);
+    const total = related.reduce((sum, question) => sum + Number(question.score || 0), 0);
+    const earned = point.sourceQuestionIds.reduce((sum, questionId) => {
+      const item = grading.find((candidate) => candidate.questionId === questionId);
+      return sum + Number(item?.score || 0);
+    }, 0);
+    const ratio = total > 0 ? earned / total : 0;
+    point.severity = ratio <= 0.35 || point.sourceQuestionIds.length >= 3 ? 'high' : ratio < 0.75 ? 'medium' : 'low';
+    point.issue = point.issueTypes.length
+      ? `${point.issueTypes.join('、')}，相关题目：${point.sourceQuestionIds.join('、')}`
+      : `相关题目 ${point.sourceQuestionIds.join('、')} 暴露出掌握不稳。`;
+    point.nextAction = point.severity === 'high'
+      ? '下次优先生成低坡度讲解后修复题，先拆步骤再综合。'
+      : '下次穿插 1-2 道同类巩固题，观察是否稳定。';
+  }
+
+  return [...byPoint.values()].sort((a, b) => {
+    const severityOrder = { high: 0, medium: 1, low: 2 };
+    return severityOrder[a.severity] - severityOrder[b.severity] ||
+      a.knowledgePointId.localeCompare(b.knowledgePointId);
+  });
+}
+
+function questionNumber(questionId) {
+  return Number(String(questionId || '').replace(/^q/, '')) || 0;
+}
+
+export function buildCorrectionPackMarkdown({ practice, grading = [], weakPoints = [] }) {
+  const questions = questionById(practice);
+  const problemItems = grading
+    .filter((item) => ['partial', 'wrong', 'unrecognized', 'needs_review'].includes(item.status))
+    .sort((a, b) => questionNumber(a.questionId) - questionNumber(b.questionId));
+
+  const lines = [
+    `# ${practice.title} 错题讲解包`,
+    '',
+    `- 练习：${practice.id}`,
+    `- 章节：${practice.chapterTitle}`,
+    `- 需讲解题数：${problemItems.length}`,
+    ''
+  ];
+
+  if (weakPoints.length) {
+    lines.push('## 薄弱知识点', '');
+    for (const point of weakPoints) {
+      lines.push(`- ${point.title}：${point.issue}。${point.nextAction}`);
+    }
+    lines.push('');
+  }
+
+  lines.push('## 错题与讲解方法', '');
+  if (!problemItems.length) {
+    lines.push('本次没有需要讲解的错题，保持这个节奏继续做间隔复查。', '');
+  }
+
+  for (const item of problemItems) {
+    const question = questions.get(item.questionId);
+    if (!question) continue;
+    lines.push(`### ${item.questionId}｜${(question.knowledgePoints || []).join('、') || '知识点待确认'}`);
+    lines.push('');
+    lines.push(`- 状态：${item.status}`);
+    lines.push(`- 得分：${Number(item.score || 0)} / ${Number(item.maxScore || question.score || 0)}`);
+    lines.push(`- 学生作答：${item.recognizedAnswer || '未能稳定识别'}`);
+    lines.push(`- 错因摘要：${item.mistakeSummary || item.comment || '待结合原卷讲解'}`);
+    if (item.errorTypes?.length) lines.push(`- 错因标签：${item.errorTypes.join('、')}`);
+    lines.push('');
+    lines.push('**标准答案：**');
+    lines.push('');
+    lines.push(item.referenceAnswer || '批改阶段未生成稳定参考答案，请结合原卷人工核对。');
+    lines.push('');
+    if (item.solutionMethod?.length) {
+      lines.push('**推荐讲解步骤：**');
+      for (const step of item.solutionMethod) lines.push(`- ${step}`);
+      lines.push('');
+    }
+    if (item.teachingHint) {
+      lines.push('**讲解提示：**');
+      lines.push('');
+      lines.push(item.teachingHint);
+      lines.push('');
+    }
+  }
+
+  return `${lines.join('\n').trim()}\n`;
+}
+
+export function buildPositiveReportMarkdown({
+  practice,
+  gradingResult,
+  knowledgeEvidence = [],
+  weakPoints = [],
+  selfCheck = null
+}) {
+  const stats = gradingStats(gradingResult.grading || []);
+  const mastered = knowledgeEvidence.filter((item) => item.result === 'mastered');
+  const masteredTitles = [...new Set(mastered.map((item) => item.knowledgePointTitle).filter(Boolean))].slice(0, 12);
+  const weakTitles = weakPoints.slice(0, 8).map((item) => item.title);
+
+  const lines = [
+    `# ${practice.title} 批改反馈`,
+    '',
+    `- 练习：${practice.id}`,
+    `- 章节：${practice.chapterTitle}`,
+    `- 题目数：${stats.totalQuestions}`,
+    `- 得分：${stats.earnedScore} / ${stats.totalScore}`,
+    `- 正确率：${stats.accuracy}%`,
+    `- 正确：${stats.correct} 题`,
+    `- 部分正确：${stats.partial} 题`,
+    `- 错误：${stats.wrong} 题`,
+    `- 无法识别：${stats.unrecognized} 题`,
+    `- 需人工确认：${stats.needsReview} 题`,
+    '',
+    '## 正向反馈',
+    '',
+    gradingResult.summary || `本次完成了 ${stats.totalQuestions} 道题，其中 ${stats.correct} 道判断为正确。`,
+    ''
+  ];
+
+  if (masteredTitles.length) {
+    lines.push('## 已表现较好的知识点', '');
+    for (const title of masteredTitles) lines.push(`- ${title}`);
+    lines.push('');
+  }
+
+  if (weakTitles.length) {
+    lines.push('## 下一步优先巩固', '');
+    for (const title of weakTitles) lines.push(`- ${title}`);
+    lines.push('');
+  }
+
+  if (gradingResult.nextPracticeSuggestion) {
+    lines.push('## 下一次练习建议', '', gradingResult.nextPracticeSuggestion, '');
+  }
+
+  if (selfCheck) {
+    lines.push('## 自动核对', '');
+    lines.push(`- 缺失题目：${selfCheck.missingQuestionIds.length ? selfCheck.missingQuestionIds.join('、') : '无'}`);
+    lines.push(`- 无效题号：${selfCheck.unknownQuestionIds.length ? selfCheck.unknownQuestionIds.join('、') : '无'}`);
+    lines.push(`- 分数异常：${selfCheck.scoreIssues.length}`);
+    lines.push(`- 二次复核题数：${selfCheck.recheckedQuestionIds.length}`);
+    lines.push('');
+  }
+
+  return `${lines.join('\n').trim()}\n`;
+}
+
+function applyMasteryMarkersToDoc(doc, chapterMastery) {
+  return {
+    ...doc,
+    sections: (doc.sections || []).map((section) => ({
+      ...section,
+      points: (section.points || []).map((point) => {
+        const mastery = chapterMastery?.points?.[point.id] || null;
+        return {
+          ...point,
+          masteryStatus: mastery?.status || point.masteryStatus || 'not_started',
+          masteryStats: mastery
+            ? {
+                coveredCount: mastery.coveredCount || 0,
+                correctCount: mastery.correctCount || 0,
+                wrongCount: mastery.wrongCount || 0,
+                lastPracticeId: mastery.lastPracticeId || null,
+                lastSubmissionId: mastery.lastSubmissionId || null,
+                lastUpdatedAt: mastery.lastUpdatedAt || null
+              }
+            : point.masteryStats || null
+        };
+      })
+    }))
+  };
+}
+
+export async function syncKnowledgeMasteryMarkers(chapterId) {
+  const chapterPaths = chapterDataPaths(chapterId);
+  const chapterMastery = await readJson(chapterPaths.mastery, null);
+  if (!chapterMastery) return null;
+
+  const chapterDoc = await readJson(chapterPaths.knowledgeJson, null);
+  if (chapterDoc) {
+    await writeJson(chapterPaths.knowledgeJson, applyMasteryMarkersToDoc(chapterDoc, chapterMastery));
+  }
+
+  const allKnowledge = await readJson(paths.knowledge, []);
+  const nextKnowledge = allKnowledge.map((doc) => (
+    doc.chapterId === chapterId ? applyMasteryMarkersToDoc(doc, chapterMastery) : doc
+  ));
+  await writeJson(paths.knowledge, nextKnowledge);
+
+  const docPath = path.join(paths.knowledgeDocs, `${chapterId}.md`);
+  const currentMarkdown = await readFile(docPath, 'utf8').catch(() => '');
+  const marker = `\n\n<!-- mastery-updated-at: ${new Date().toISOString()} -->\n`;
+  await writeFile(docPath, `${currentMarkdown.replace(/\n\n<!-- mastery-updated-at: .*? -->\n?$/s, '').trim()}${marker}`, 'utf8');
+  await syncGlobalIndexes();
+  return chapterMastery;
+}

package/server/llmConfig.js

@@ -0,0 +1,96 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { paths } from './fileStore.js';
+
+const ENV_KEYS = ['AI_BASE_URL', 'AI_API_KEY', 'AI_MODEL'];
+
+function envPath() {
+  if (process.env.MATH_AGENT_ENV_FILE) return path.resolve(process.env.MATH_AGENT_ENV_FILE);
+  if (process.env.MATH_AGENT_DATA_DIR) return path.resolve(process.env.MATH_AGENT_DATA_DIR, '..', '.env.local');
+  return path.join(paths.rootDir, '.env.local');
+}
+
+function parseEnvText(text) {
+  const values = {};
+  for (const line of text.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+    const match = trimmed.match(/^([A-Za-z_][A-Za-z0-9_]*)=(.*)$/);
+    if (!match) continue;
+    values[match[1]] = match[2].replace(/^"(.*)"$/, '$1');
+  }
+  return values;
+}
+
+async function readLocalEnvText() {
+  try {
+    return await readFile(envPath(), 'utf8');
+  } catch (error) {
+    if (error.code === 'ENOENT') return '';
+    throw error;
+  }
+}
+
+function serializeValue(value) {
+  const text = String(value ?? '');
+  if (!/[\s#"'\\]/.test(text)) return text;
+  return JSON.stringify(text);
+}
+
+function mergeEnvText(text, updates) {
+  const seen = new Set();
+  const lines = text.split(/\r?\n/).filter((line, index, lines) => index < lines.length - 1 || line !== '');
+  const nextLines = lines.map((line) => {
+    const match = line.match(/^([A-Za-z_][A-Za-z0-9_]*)=/);
+    if (!match || !(match[1] in updates)) return line;
+    seen.add(match[1]);
+    return `${match[1]}=${serializeValue(updates[match[1]])}`;
+  });
+  for (const key of ENV_KEYS) {
+    if (key in updates && !seen.has(key)) nextLines.push(`${key}=${serializeValue(updates[key])}`);
+  }
+  return `${nextLines.join('\n')}\n`;
+}
+
+export async function readLlmSettings() {
+  const fileValues = parseEnvText(await readLocalEnvText());
+  const baseUrl = process.env.AI_BASE_URL || fileValues.AI_BASE_URL || '';
+  const apiKey = process.env.AI_API_KEY || fileValues.AI_API_KEY || '';
+  const model = process.env.AI_MODEL || fileValues.AI_MODEL || 'gpt-5.5';
+  return {
+    baseUrl,
+    model,
+    hasApiKey: Boolean(apiKey),
+    envPath: envPath()
+  };
+}
+
+export async function getLlmRuntimeConfig() {
+  const fileValues = parseEnvText(await readLocalEnvText());
+  return {
+    baseUrl: process.env.AI_BASE_URL || fileValues.AI_BASE_URL || '',
+    apiKey: process.env.AI_API_KEY || fileValues.AI_API_KEY || '',
+    model: process.env.AI_MODEL || fileValues.AI_MODEL || 'gpt-5.5'
+  };
+}
+
+export async function writeLlmSettings(input = {}) {
+  const current = await readLlmSettings();
+  const baseUrl = String(input.baseUrl ?? current.baseUrl ?? '').trim();
+  const model = String(input.model ?? current.model ?? 'gpt-5.5').trim();
+  const apiKeyInput = String(input.apiKey ?? '').trim();
+  const clearApiKey = Boolean(input.clearApiKey);
+  const updates = {
+    AI_BASE_URL: baseUrl,
+    AI_MODEL: model || 'gpt-5.5'
+  };
+  if (clearApiKey) updates.AI_API_KEY = '';
+  if (apiKeyInput) updates.AI_API_KEY = apiKeyInput;
+
+  const nextText = mergeEnvText(await readLocalEnvText(), updates);
+  await writeFile(envPath(), nextText, 'utf8');
+  for (const [key, value] of Object.entries(updates)) {
+    process.env[key] = value;
+  }
+  return readLlmSettings();
+}

package/server/mistakeLifecycle.js

@@ -0,0 +1,251 @@
+import { randomUUID } from 'node:crypto';
+import {
+  isActionableMistake,
+  isResolvedMistake,
+  normalizeMistakeRecord,
+  readChapterMistakes,
+  writeChapterMistakes
+} from './fileStore.js';
+
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function questionKnowledgePointIds(question = {}) {
+  return unique(Array.isArray(question.knowledgePointIds) ? question.knowledgePointIds : []);
+}
+
+function mistakeKnowledgePointIds(mistake = {}) {
+  const normalized = normalizeMistakeRecord(mistake);
+  return unique([
+    ...(Array.isArray(normalized.sourceKnowledgePointIds) ? normalized.sourceKnowledgePointIds : []),
+    normalized.knowledgePointId
+  ]);
+}
+
+function overlaps(left = [], right = []) {
+  const rightSet = new Set(right);
+  return left.some((item) => rightSet.has(item));
+}
+
+function questionMatchesMistake(question, mistake) {
+  return overlaps(questionKnowledgePointIds(question), mistakeKnowledgePointIds(mistake));
+}
+
+function isCorrectGrading(item = {}, question = {}) {
+  const maxScore = Number(item.maxScore || question.score || 0);
+  const score = Number(item.score || 0);
+  const ratio = maxScore > 0 ? score / maxScore : 0;
+  return item.status === 'correct' || ratio >= 0.85;
+}
+
+function isWeakGrading(item = {}, question = {}) {
+  return !isCorrectGrading(item, question)
+    && ['wrong', 'partial', 'needs_review', 'unrecognized'].includes(item.status);
+}
+
+function mistakeEvent(type, details = {}) {
+  return {
+    type,
+    at: new Date().toISOString(),
+    ...details
+  };
+}
+
+function severityForMistake(mistake) {
+  if (mistake.status === 'regressed') return 'high';
+  if (Number(mistake.occurrences || 1) >= 3) return 'high';
+  if (Number(mistake.occurrences || 1) >= 2) return 'medium';
+  return 'low';
+}
+
+export function weakPointsFromMistakes(mistakes, { includeResolved = false } = {}) {
+  const candidates = mistakes
+    .map(normalizeMistakeRecord)
+    .filter((mistake) => includeResolved || isActionableMistake(mistake));
+  const byPoint = new Map();
+  for (const mistake of candidates) {
+    const pointId = mistake.knowledgePointId || mistakeKnowledgePointIds(mistake)[0] || '';
+    if (!pointId) continue;
+    const current = byPoint.get(pointId) || {
+      knowledgePointId: pointId,
+      knowledgePoint: mistake.knowledgePoint || '待确认',
+      issue: mistake.summary || '待修复错因',
+      nextAction: '生成易错题练习进行修复。',
+      severity: severityForMistake(mistake),
+      status: mistake.status,
+      occurrences: 0,
+      latestSubmissionId: mistake.submissionId || null,
+      latestPracticeId: mistake.practiceId || null,
+      mistakeIds: [],
+      sourceQuestionIds: [],
+      sourceKnowledgePointIds: []
+    };
+    current.occurrences += Number(mistake.occurrences || 1);
+    current.severity = severityForMistake({ ...mistake, occurrences: current.occurrences });
+    current.status = current.status === 'regressed' || mistake.status === 'regressed'
+      ? 'regressed'
+      : mistake.status;
+    current.mistakeIds = unique([...current.mistakeIds, mistake.id]);
+    current.sourceQuestionIds = unique([...current.sourceQuestionIds, mistake.questionId]);
+    current.sourceKnowledgePointIds = unique([
+      ...current.sourceKnowledgePointIds,
+      ...mistakeKnowledgePointIds(mistake)
+    ]);
+    if (mistake.createdAt && (!current.createdAt || mistake.createdAt > current.createdAt)) {
+      current.createdAt = mistake.createdAt;
+      current.latestSubmissionId = mistake.submissionId || current.latestSubmissionId;
+      current.latestPracticeId = mistake.practiceId || current.latestPracticeId;
+      current.issue = mistake.summary || current.issue;
+    }
+    byPoint.set(pointId, current);
+  }
+  const severityOrder = { high: 0, medium: 1, low: 2 };
+  return [...byPoint.values()].sort((a, b) => (
+    severityOrder[a.severity] - severityOrder[b.severity] ||
+    b.occurrences - a.occurrences ||
+    a.knowledgePointId.localeCompare(b.knowledgePointId)
+  ));
+}
+
+export async function markRepairPracticeStarted(practice) {
+  if (practice.type !== 'mistake_repair') return [];
+  const questionPointIds = unique((practice.questions || []).flatMap(questionKnowledgePointIds));
+  if (!questionPointIds.length) return [];
+  const mistakes = await readChapterMistakes(practice.chapterId);
+  let changed = false;
+  const next = mistakes.map((mistake) => {
+    const normalized = normalizeMistakeRecord(mistake);
+    if (!isActionableMistake(normalized) || !overlaps(mistakeKnowledgePointIds(normalized), questionPointIds)) {
+      return normalized;
+    }
+    changed = true;
+    return {
+      ...normalized,
+      status: 'practicing',
+      resolved: false,
+      lastRepairPracticeId: practice.id,
+      practicingAt: new Date().toISOString(),
+      repairEvidence: [
+        ...(normalized.repairEvidence || []),
+        mistakeEvent('repair_practice_generated', { practiceId: practice.id })
+      ]
+    };
+  });
+  return changed ? writeChapterMistakes(practice.chapterId, next) : next;
+}
+
+function findExistingMistake(mistakes, { question, errorType, preferRepairPracticeId = null }) {
+  const matching = mistakes.filter((mistake) => questionMatchesMistake(question, mistake));
+  return matching.find((mistake) => (
+    preferRepairPracticeId && mistake.lastRepairPracticeId === preferRepairPracticeId
+  )) || matching.find((mistake) => (
+    !isResolvedMistake(mistake) && (!errorType || mistake.errorType === errorType)
+  )) || matching.find((mistake) => !isResolvedMistake(mistake)) || matching[0] || null;
+}
+
+function upsertWrongMistake({ mistakes, practice, submissionId, gradingItem, question }) {
+  const errorType = gradingItem.errorTypes?.[0] || '待确认';
+  const existing = findExistingMistake(mistakes, {
+    question,
+    errorType,
+    preferRepairPracticeId: practice.type === 'mistake_repair' ? practice.id : null
+  });
+  const pointIds = questionKnowledgePointIds(question);
+  const primaryPointId = pointIds[0] || null;
+  const event = mistakeEvent(isResolvedMistake(existing) ? 'mistake_regressed' : 'mistake_observed', {
+    practiceId: practice.id,
+    submissionId,
+    questionId: gradingItem.questionId,
+    status: gradingItem.status
+  });
+  if (existing) {
+    existing.status = isResolvedMistake(existing) ? 'regressed' : 'open';
+    existing.resolved = false;
+    existing.resolvedAt = null;
+    existing.practiceId = practice.id;
+    existing.submissionId = submissionId;
+    existing.questionId = gradingItem.questionId;
+    existing.knowledgePointId = existing.knowledgePointId || primaryPointId;
+    existing.sourceKnowledgePointIds = unique([
+      ...mistakeKnowledgePointIds(existing),
+      ...pointIds
+    ]);
+    existing.knowledgePoint = question.knowledgePoints?.[0] || existing.knowledgePoint || '待确认';
+    existing.errorType = errorType;
+    existing.summary = gradingItem.comment || gradingItem.teachingHint || existing.summary || '归档错题';
+    existing.occurrences = Number(existing.occurrences || 1) + 1;
+    existing.lastObservedAt = new Date().toISOString();
+    existing.repairEvidence = [...(existing.repairEvidence || []), event];
+    return existing;
+  }
+  const created = {
+    id: `mistake-${randomUUID().slice(0, 8)}`,
+    chapterId: practice.chapterId,
+    practiceId: practice.id,
+    submissionId,
+    questionId: gradingItem.questionId,
+    knowledgePointId: primaryPointId,
+    sourceKnowledgePointIds: pointIds,
+    knowledgePoint: question.knowledgePoints?.[0] || '待确认',
+    errorType,
+    summary: gradingItem.comment || gradingItem.teachingHint || '归档错题',
+    status: 'open',
+    occurrences: 1,
+    reviewDates: [],
+    resolved: false,
+    repairEvidence: [event],
+    createdAt: new Date().toISOString()
+  };
+  mistakes.push(created);
+  return created;
+}
+
+function resolveRepairMistakes({ mistakes, practice, grading, questionById, submissionId }) {
+  if (practice.type !== 'mistake_repair') return;
+  const outcomes = new Map();
+  for (const item of grading) {
+    const question = questionById.get(item.questionId);
+    if (!question) continue;
+    for (const pointId of questionKnowledgePointIds(question)) {
+      const current = outcomes.get(pointId) || { correct: 0, weak: 0 };
+      if (isCorrectGrading(item, question)) current.correct += 1;
+      if (isWeakGrading(item, question)) current.weak += 1;
+      outcomes.set(pointId, current);
+    }
+  }
+  for (const mistake of mistakes) {
+    const normalized = normalizeMistakeRecord(mistake);
+    if (normalized.status !== 'practicing' && normalized.lastRepairPracticeId !== practice.id) continue;
+    const relatedOutcomes = mistakeKnowledgePointIds(normalized)
+      .map((pointId) => outcomes.get(pointId))
+      .filter(Boolean);
+    if (!relatedOutcomes.length) continue;
+    const hasCorrect = relatedOutcomes.some((item) => item.correct > 0);
+    const hasWeak = relatedOutcomes.some((item) => item.weak > 0);
+    if (hasCorrect && !hasWeak) {
+      mistake.status = 'resolved';
+      mistake.resolved = true;
+      mistake.resolvedAt = new Date().toISOString();
+      mistake.repairEvidence = [
+        ...(mistake.repairEvidence || []),
+        mistakeEvent('repair_confirmed_resolved', {
+          practiceId: practice.id,
+          submissionId
+        })
+      ];
+    }
+  }
+}
+
+export async function updateMistakesAfterArchive({ practice, grading, submissionId }) {
+  const mistakes = (await readChapterMistakes(practice.chapterId)).map(normalizeMistakeRecord);
+  const questionById = new Map((practice.questions || []).map((question) => [question.id, question]));
+  for (const item of grading) {
+    const question = questionById.get(item.questionId);
+    if (!question || !isWeakGrading(item, question)) continue;
+    upsertWrongMistake({ mistakes, practice, submissionId, gradingItem: item, question });
+  }
+  resolveRepairMistakes({ mistakes, practice, grading, questionById, submissionId });
+  return writeChapterMistakes(practice.chapterId, mistakes);
+}