@zhouchangui/math-ati 0.1.3 → 0.1.4

package/server/index.js

@@ -152,6 +152,54 @@ app.put('/api/profile', async (req, res, next) => {
   }
 });
 
+// ── First-time setup ────────────────────────────────────────────────
+
+app.get('/api/setup/status', async (req, res, next) => {
+  try {
+    const profile = await readJson(paths.profile, null).catch(() => null);
+    const needsSetup = !profile?.setupCompletedAt;
+    res.json({ needsSetup });
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.post('/api/setup', async (req, res, next) => {
+  try {
+    const body = req.body || {};
+    const profileFields = body.profile || {};
+    const llm = body.llm || {};
+
+    // Save profile with setup completion marker
+    const current = await readJson(paths.profile, {}).catch(() => ({}));
+    const profile = {
+      ...current,
+      name: String(profileFields.name || current.name || '学生').trim(),
+      gender: String(profileFields.gender || current.gender || '').trim(),
+      age: Number.isFinite(Number(profileFields.age)) ? Number(profileFields.age) : current.age || 14,
+      stage: String(profileFields.stage || current.stage || '').trim(),
+      primaryGoal: String(profileFields.primaryGoal || current.primaryGoal || '').trim(),
+      priorityTrack: String(profileFields.priorityTrack || current.priorityTrack || '').trim(),
+      preferences: String(profileFields.preferences || current.preferences || '').trim(),
+      profileNotes: String(profileFields.profileNotes || current.profileNotes || '').trim(),
+      setupCompletedAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    };
+    await writeJson(paths.profile, profile);
+
+    // Save LLM settings
+    await writeLlmSettings({
+      baseUrl: llm.baseUrl,
+      model: llm.model,
+      apiKey: llm.apiKey
+    });
+
+    res.json({ ok: true });
+  } catch (error) {
+    next(error);
+  }
+});
+
 app.get('/api/settings/llm', async (req, res, next) => {
   try {
     res.json(await readLlmSettings());

package/server/knowledgeExtractor.js

@@ -13,10 +13,10 @@ import {
 } from './fileStore.js';
 import { promptPayload, readPrompt } from './promptStore.js';
 
-const KNOWLEDGE_PAGE_TIMEOUT_MS = Number(process.env.KNOWLEDGE_EXTRACT_PAGE_TIMEOUT_MS || 180000);
-const KNOWLEDGE_SUMMARY_TIMEOUT_MS = Number(process.env.KNOWLEDGE_EXTRACT_SUMMARY_TIMEOUT_MS || 120000);
-const KNOWLEDGE_PAGE_RETRIES = Number(process.env.KNOWLEDGE_EXTRACT_PAGE_RETRIES || 2);
-const KNOWLEDGE_SUMMARY_RETRIES = Number(process.env.KNOWLEDGE_EXTRACT_SUMMARY_RETRIES || 2);
+const KNOWLEDGE_PAGE_TIMEOUT_MS = Number(process.env.KNOWLEDGE_EXTRACT_PAGE_TIMEOUT_MS || 300000);
+const KNOWLEDGE_SUMMARY_TIMEOUT_MS = Number(process.env.KNOWLEDGE_EXTRACT_SUMMARY_TIMEOUT_MS || 600000);
+const KNOWLEDGE_PAGE_RETRIES = Number(process.env.KNOWLEDGE_EXTRACT_PAGE_RETRIES || 3);
+const KNOWLEDGE_SUMMARY_RETRIES = Number(process.env.KNOWLEDGE_EXTRACT_SUMMARY_RETRIES || 3);
 const KNOWLEDGE_SUMMARY_PAGE_CHUNK_SIZE = Number(process.env.KNOWLEDGE_SUMMARY_PAGE_CHUNK_SIZE || 4);
 const KNOWLEDGE_MAX_CORE_POINTS = Number(process.env.KNOWLEDGE_MAX_CORE_POINTS || 24);
 const KNOWLEDGE_MAX_MISTAKE_POINTS = Number(process.env.KNOWLEDGE_MAX_MISTAKE_POINTS || 8);
@@ -213,6 +213,7 @@ export async function extractChapterPage({
   pageCount = 0,
   force = false,
   extractProfile = null,
+  chapterStructure = '',
   onProgress = null
 }) {
   await ensureChapterWorkspace(chapter);
@@ -249,6 +250,7 @@ export async function extractChapterPage({
       `章节：${chapter.id} ${chapter.fullTitle}`,
       `主线：${chapter.track}`,
       `提取策略：考点和易错点优先；不要把例子拆成独立知识点；不要补充图片没有出现的内容。`,
+      chapterStructure ? `\n以下是本《${chapter.fullTitle}》的章节整体结构分析，供逐页提取时参考。请在提取本页时注意：\n- 本页在章节中的大致角色\n- 本页涉及的核心概念是否已在结构分析中列出\n- 本页知识点与前后页的关联关系\n\n${chapterStructure.slice(0, 3000)}` : '',
       '',
       '输出必须是 Markdown，且只包含以下标题：',
       '# 页面知识提取',
@@ -371,6 +373,23 @@ function normalizePointForBudget(point) {
     formulas: Array.isArray(point.formulas) ? point.formulas.filter(Boolean).slice(0, 4) : [],
     pitfalls: Array.isArray(point.pitfalls) ? point.pitfalls.filter(Boolean).slice(0, 5) : [],
     examples: Array.isArray(point.examples) ? point.examples.filter(Boolean).slice(0, 4) : [],
+    teachingTips: point.teachingTips && typeof point.teachingTips === 'object'
+      ? {
+          commonMisconceptions: Array.isArray(point.teachingTips.commonMisconceptions)
+            ? point.teachingTips.commonMisconceptions.filter(Boolean).slice(0, 3)
+            : [],
+          scaffoldingOrder: Array.isArray(point.teachingTips.scaffoldingOrder)
+            ? point.teachingTips.scaffoldingOrder.filter(Boolean).slice(0, 4)
+            : [],
+          checkUnderstandingQuestions: Array.isArray(point.teachingTips.checkUnderstandingQuestions)
+            ? point.teachingTips.checkUnderstandingQuestions.filter(Boolean).slice(0, 2)
+            : []
+        }
+      : point.teachingTips || {
+          commonMisconceptions: [],
+          scaffoldingOrder: [],
+          checkUnderstandingQuestions: []
+        },
     questionTemplates: Array.isArray(point.questionTemplates) && point.questionTemplates.length
       ? point.questionTemplates.filter((template) => Array.isArray(template)).slice(0, 3)
       : [[
@@ -403,6 +422,27 @@ function mergeDuplicatePoints(points) {
       ))
       .slice(0, 3);
     current.sources = [...new Set([...(current.sources || []), ...(point.sources || [])])];
+    if (point.teachingTips && typeof point.teachingTips === 'object') {
+      const currentTips = current.teachingTips || { commonMisconceptions: [], scaffoldingOrder: [], checkUnderstandingQuestions: [] };
+      const pointTips = point.teachingTips;
+      current.teachingTips = {
+        commonMisconceptions: [
+          ...new Set([
+            ...(Array.isArray(currentTips.commonMisconceptions) ? currentTips.commonMisconceptions : []),
+            ...(Array.isArray(pointTips.commonMisconceptions) ? pointTips.commonMisconceptions : [])
+          ])
+        ].slice(0, 4),
+        scaffoldingOrder: Array.isArray(pointTips.scaffoldingOrder) && pointTips.scaffoldingOrder.length
+          ? pointTips.scaffoldingOrder
+          : currentTips.scaffoldingOrder || [],
+        checkUnderstandingQuestions: [
+          ...new Set([
+            ...(Array.isArray(currentTips.checkUnderstandingQuestions) ? currentTips.checkUnderstandingQuestions : []),
+            ...(Array.isArray(pointTips.checkUnderstandingQuestions) ? pointTips.checkUnderstandingQuestions : [])
+          ])
+        ].slice(0, 3)
+      };
+    }
   }
   return [...byKey.values()];
 }
@@ -429,16 +469,18 @@ function enforceKnowledgeBudget(chapter, doc, profile) {
       else corePoints.push(point);
     }
   }
+  // Knowledge points may be de-duplicated and merged, but must never be dropped
+  // just to fit a numeric budget — losing knowledge points corrupts the chapter's
+  // coverage/mastery loop. The budget values are only a target hint passed to the
+  // extract/summary agent prompts upstream; the post-processing here only de-dups.
   const dedupedCore = mergeDuplicatePoints(corePoints)
     .sort((a, b) => pointPriority(b) - pointPriority(a))
-    .slice(0, maxCore)
     .map((point, index) => ({
       ...point,
       id: `${chapter.id}-kp-${String(index + 1).padStart(2, '0')}`
     }));
   const dedupedMistakes = mergeDuplicatePoints(mistakePoints)
     .sort((a, b) => pointPriority(b) - pointPriority(a))
-    .slice(0, maxMistakes)
     .map((point, index) => ({
       ...point,
       id: `${chapter.id}-mistake-${String(index + 1).padStart(2, '0')}`
@@ -495,6 +537,14 @@ function localMergeChapter(chapter, pageExtracts) {
               point.title
             ]
           ],
+          teachingTips: {
+            commonMisconceptions: (point.pitfalls || []).slice(0, 2)
+              .map((pitfall) => `常见的误解：${pitfall}`),
+            scaffoldingOrder: [`先理解「${point.title}」的基本定义`, `再通过例子巩固`, `最后独立完成变式题`],
+            checkUnderstandingQuestions: [
+              `用自己的话解释什么是「${point.title}」，并举一个例子。`
+            ]
+          },
           sources: point.sources || []
         }))
       },
@@ -514,6 +564,11 @@ function localMergeChapter(chapter, pageExtracts) {
               mistake.errorType || mistake.title
             ]
           ],
+          teachingTips: {
+            commonMisconceptions: [mistake.description || mistake.errorType || mistake.title || '易错点'].filter(Boolean).slice(0, 2),
+            scaffoldingOrder: ['先识别错误类型', '再用正确方法重新做一遍'],
+            checkUnderstandingQuestions: ['这个易错点最容易在什么情况下出现？如何避免？']
+          },
           sources: mistake.sources || []
         }))
       }
@@ -571,6 +626,11 @@ function knowledgeSummarySchema(chapter) {
         pitfalls: ['string'],
         examples: ['string'],
         questionTemplates: [['stem', 'answer', 'expectedErrorType']],
+        teachingTips: {
+          commonMisconceptions: ['string'],
+          scaffoldingOrder: ['string'],
+          checkUnderstandingQuestions: ['string']
+        },
         sources: ['image filename']
       }]
     }],
@@ -608,62 +668,97 @@ async function summarizePageChunk({ chapter, pages, chunkIndex, chunkCount, syst
     chunkCount,
     pageCount: pages.length
   });
-  const agent = await callChatTextAgent({
-    system: systemPrompt,
-    timeoutMs: KNOWLEDGE_SUMMARY_TIMEOUT_MS,
-    retries: KNOWLEDGE_SUMMARY_RETRIES,
-    temperature: 0.1,
-    user: [
-      `任务：合并《${chapter.fullTitle}》第 ${chunkIndex + 1}/${chunkCount} 组逐页 Markdown 提取结果。`,
-      '',
-      `本组页面：${pageLabels}`,
-      `数量控制：核心知识点不超过 ${Math.ceil(normalizedProfile.maxCorePointCount / chunkCount) + 4} 个；易错点不超过 ${Math.ceil(normalizedProfile.maxMistakePointCount / chunkCount) + 2} 个。`,
-      '',
-      '要求：',
-      '- 只基于输入页面合并知识点，不新增页面没有依据的内容。',
-      '- 合并同义、过细、重复候选，保留来源页。',
-      '- 优先保留考试常见考点、易错边界、几何概念辨析和可出题的方法。',
-      '- 输出 Markdown，不输出 JSON。',
-      '- 必须包含标题：# 分组知识汇总、## 知识点覆盖、## 易错题专项、## 合并说明。',
-      '- 每个知识点用三级标题，包含：摘要、来源、公式、易错边界、出题模板。',
-      '',
-      '逐页 Markdown：',
-      ...pages.map((page) => [
-        `\n---\n`,
-        `来源页：${page.imageFile}`,
-        page.markdown || ''
-      ].join('\n'))
-    ].join('\n'),
-    onAttempt: ({ phase, attempt, attempts, delayMs, result }) => {
-      if (phase === 'start') {
-        onProgress?.({
-          step: 'knowledge_extract.summary.chunk.attempt',
-          message: `知识点分组 ${chunkIndex + 1}/${chunkCount}：第 ${attempt}/${attempts} 次尝试。`,
-          attempt,
-          attempts
-        });
-      }
-      if (phase === 'retry') {
-        onProgress?.({
-          step: 'knowledge_extract.summary.chunk.retry',
-          message: `知识点分组 ${chunkIndex + 1}/${chunkCount} 遇到${retryReasonText(result?.reason)}，${Math.round(delayMs / 1000)} 秒后自动重试。`,
-          attempt,
-          attempts,
-          reason: result?.reason || null
-        });
-      }
+  // The prompt requires a structured Markdown doc ("# 分组知识汇总", "## 知识点覆盖",
+  // "## 易错题专项"). Some models leak reasoning as a leading sentence and skip the
+  // requested structure, producing a chunk with zero knowledge points. callChatTextAgent
+  // returns responseFormat: 'text', so such leakage is reported as ok and is not retried
+  // at the agent level. Retry the chunk in place so one bad chunk does not force a whole-
+  // chapter redo (which would discard the other chunk's valid cached summary).
+  const requiredHeadings = /^#\s+分组知识汇总/m;
+  const structureAttempts = Number(process.env.KNOWLEDGE_SUMMARY_STRUCTURE_RETRIES || 3);
+  const userPayload = [
+    `任务：合并《${chapter.fullTitle}》第 ${chunkIndex + 1}/${chunkCount} 组逐页 Markdown 提取结果。`,
+    '',
+    `本组页面：${pageLabels}`,
+    `数量控制：核心知识点不超过 ${Math.ceil(normalizedProfile.maxCorePointCount / chunkCount) + 4} 个；易错点不超过 ${Math.ceil(normalizedProfile.maxMistakePointCount / chunkCount) + 2} 个。`,
+    '',
+    '要求：',
+    '- 只基于输入页面合并知识点，不新增页面没有依据的内容。',
+    '- 合并同义、过细、重复候选，保留来源页。',
+    '- 优先保留考试常见考点、易错边界、几何概念辨析和可出题的方法。',
+    '- 输出 Markdown，不输出 JSON。',
+    '- 必须包含标题：# 分组知识汇总、## 知识点覆盖、## 易错题专项、## 合并说明。',
+    '- 每个知识点用三级标题，包含：摘要、来源、公式、易错边界、出题模板。直接输出结果，不要输出思考过程或开场白。',
+    '',
+    '逐页 Markdown：',
+    ...pages.map((page) => [
+      `\n---\n`,
+      `来源页：${page.imageFile}`,
+      page.markdown || ''
+    ].join('\n'))
+  ].join('\n');
+  const handleAttempt = ({ phase, attempt, attempts, delayMs, result }) => {
+    if (phase === 'start') {
+      onProgress?.({
+        step: 'knowledge_extract.summary.chunk.attempt',
+        message: `知识点分组 ${chunkIndex + 1}/${chunkCount}：第 ${attempt}/${attempts} 次尝试。`,
+        attempt,
+        attempts
+      });
     }
-  });
-  if (!agent.ok || !agent.data) {
+    if (phase === 'retry') {
+      onProgress?.({
+        step: 'knowledge_extract.summary.chunk.retry',
+        message: `知识点分组 ${chunkIndex + 1}/${chunkCount} 遇到${retryReasonText(result?.reason)}，${Math.round(delayMs / 1000)} 秒后自动重试。`,
+        attempt,
+        attempts,
+        reason: result?.reason || null
+      });
+    }
+  };
+  let markdown = '';
+  let pointHeadings = 0;
+  for (let structureAttempt = 1; structureAttempt <= structureAttempts; structureAttempt += 1) {
+    const agent = await callChatTextAgent({
+      system: systemPrompt,
+      timeoutMs: KNOWLEDGE_SUMMARY_TIMEOUT_MS,
+      retries: KNOWLEDGE_SUMMARY_RETRIES,
+      temperature: 0.1,
+      user: userPayload,
+      onAttempt: handleAttempt
+    });
+    if (!agent.ok || !agent.data) {
+      throw knowledgeExtractionError(
+        agent.reason || 'empty_response',
+        `知识点分组 ${chunkIndex + 1}/${chunkCount} 合并失败，已尝试 ${agent.attempts || 1} 次。${agent.detail || ''}`.trim()
+      );
+    }
+    markdown = String(agent.data || '').trim();
+    pointHeadings = (markdown.match(/^###\s+/gm) || []).length;
+    if (requiredHeadings.test(markdown) && pointHeadings > 0) {
+      break;
+    }
+    onProgress?.({
+      step: 'knowledge_extract.summary.chunk.structure_retry',
+      message: `知识点分组 ${chunkIndex + 1}/${chunkCount} 第 ${structureAttempt}/${structureAttempts} 次返回缺少结构或知识点，重新生成。`,
+      chunkIndex: chunkIndex + 1,
+      chunkCount,
+      structureAttempt,
+      structureAttempts
+    });
+    if (structureAttempt < structureAttempts) {
+      await new Promise((resolve) => setTimeout(resolve, 2000));
+    }
+  }
+  if (!requiredHeadings.test(markdown) || pointHeadings === 0) {
     throw knowledgeExtractionError(
-      agent.reason || 'empty_response',
-      `知识点分组 ${chunkIndex + 1}/${chunkCount} 合并失败，已尝试 ${agent.attempts || 1} 次。${agent.detail || ''}`.trim()
+      'invalid_chunk_structure',
+      `知识点分组 ${chunkIndex + 1}/${chunkCount} 输出缺少必需的 Markdown 结构或知识点，已重试 ${structureAttempts} 次。`
     );
   }
-  const markdown = String(agent.data || '').trim();
   await mkdir(chunkSummaryDir(chapter.id), { recursive: true });
   await writeFile(chunkSummaryPath(chapter.id, chunkIndex), `${markdown}\n`, 'utf8');
-  const knowledgePointCount = (markdown.match(/^###\s+/gm) || []).length;
+  const knowledgePointCount = pointHeadings;
   onProgress?.({
     step: 'knowledge_extract.summary.chunk.done',
     message: `知识点分组 ${chunkIndex + 1}/${chunkCount} 合并完成，得到约 ${knowledgePointCount} 个候选点。`,
@@ -790,11 +885,25 @@ export async function summarizeChapterExtraction({
     chunkCount: chunkDocs.length
   });
   let finalDoc = null;
-  if (pageChunks.length > 1) {
-    finalDoc = localMergeChunkSummaries(chapter, chunkDocs);
+  // Prefer the deterministic local merge so the final chapter doc is built
+  // from real per-page / per-chunk agent outputs (now structurally validated,
+  // with chunk-level retries on bad output) instead of an additional free-form
+  // LLM merge that can lose points or return invalid JSON. When the chapter
+  // fits in a single chunk the chunk summary is skipped, so fall back to
+  // localMergeChapter which parses per-page knowledge points directly.
+  const localDoc = chunkDocs.length > 0
+    ? localMergeChunkSummaries(chapter, chunkDocs)
+    : local;
+  const hasUsableSections = (localDoc.sections || []).some(
+    (section) => Array.isArray(section.points) && section.points.length > 0
+  );
+  if (hasUsableSections) {
+    finalDoc = localDoc;
     onProgress?.({
       step: 'knowledge_extract.summary.final.local',
-      message: `已从 ${chunkDocs.length} 个分组 Markdown 生成最终章节知识草稿，正在去重和限量。`,
+      message: `已从 ${chunkDocs.length} 个分组 Markdown 本地合并为最终章节知识，共约 ${
+        (localDoc.sections || []).reduce((sum, s) => sum + (s.points || []).length, 0)
+      } 个候选点。`,
       chunkCount: chunkDocs.length
     });
   } else {
@@ -878,6 +987,55 @@ export async function extractChapterKnowledge({
       pageCount: scopedImages.length
     });
     const pageExtracts = [];
+    // Phase 0: analyze chapter structure with sampled pages
+    const structureSampleSize = Math.min(
+      Number(process.env.KNOWLEDGE_STRUCTURE_SAMPLE_PAGES || 6),
+      scopedImages.length
+    );
+    let chapterStructure = '';
+    const structureCachePath = path.join(chapterDataPaths(chapter.id).context, 'chapter_structure.md');
+    const cachedStructure = force ? '' : await readFile(structureCachePath, 'utf8').catch(() => '');
+    if (cachedStructure) {
+      chapterStructure = cachedStructure;
+      onProgress?.({
+        step: 'knowledge_extract.structure.cached',
+        message: '章节结构分析已有缓存，直接复用。'
+      });
+    } else {
+      onProgress?.({
+        step: 'knowledge_extract.structure.start',
+        message: `正在分析《${chapter.fullTitle}》章节结构（抽样 ${structureSampleSize}/${scopedImages.length} 页）。`
+      });
+      const sampleImages = scopedImages.slice(0, structureSampleSize);
+      const structurePrompt = await readPrompt('knowledge-structure.system.md');
+      const structureAgent = await callVisionTextAgent({
+        timeoutMs: Math.max(120000, KNOWLEDGE_PAGE_TIMEOUT_MS),
+        retries: 1,
+        system: structurePrompt,
+        text: [
+          `任务：快速浏览《${chapter.fullTitle}》（${chapter.track}）的章节图片，输出整体结构框架。`,
+          '',
+          '要求：只做结构概览，不做详细提取。识别核心概念、主要公式/法则、常见易错类型、每页角色（概念引入/定义/推导/例题/总结）。'
+        ].join('\n'),
+        imagePaths: sampleImages,
+        onAttempt: null
+      });
+      if (structureAgent.ok && structureAgent.data) {
+        chapterStructure = String(structureAgent.data || '').trim();
+        await mkdir(path.dirname(structureCachePath), { recursive: true });
+        await writeFile(structureCachePath, `${chapterStructure}\n`, 'utf8');
+        onProgress?.({
+          step: 'knowledge_extract.structure.done',
+          message: `章节结构分析完成，已缓存。`
+        });
+      } else {
+        chapterStructure = `# 章节结构分析\n\n## 章节主题\n${chapter.fullTitle}\n\n## 核心概念\n（结构分析未能完成，逐页提取将独立进行）\n`;
+        onProgress?.({
+          step: 'knowledge_extract.structure.failed',
+          message: `章节结构分析失败：${structureAgent.reason || 'unknown'}，继续逐页提取。`
+        });
+      }
+    }
     for (let index = 0; index < scopedImages.length; index += 1) {
       pageExtracts.push(await extractChapterPage({
         chapter,
@@ -886,6 +1044,7 @@ export async function extractChapterKnowledge({
         pageCount: scopedImages.length,
         force,
         extractProfile: normalizedProfile,
+        chapterStructure,
         onProgress
       }));
     }

package/server/knowledgeFeedback.js

@@ -295,5 +295,74 @@ export async function syncKnowledgeMasteryMarkers(chapterId) {
   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();
+  await updateStudentLearningState();
   return chapterMastery;
 }
+
+export async function updateStudentLearningState() {
+  const profile = await readJson(paths.profile, {});
+  const accuracyHistoryPath = path.join(paths.rootDir, 'data', 'global', '.accuracy_history.json');
+  let accuracyHistory = await readJson(accuracyHistoryPath, []);
+
+  // Collect accuracy from recent chapter mastery snapshots
+  const chapters = await readJson(paths.chapters, []);
+  let latestAccuracy = null;
+  for (const chapter of chapters) {
+    const chapterPaths = chapterDataPaths(chapter.id);
+    const chapterMastery = await readJson(chapterPaths.mastery, null);
+    if (!chapterMastery?.coverage) continue;
+    const { totalQuestions = 0, correctQuestions = 0 } = chapterMastery.coverage;
+    if (totalQuestions > 0) {
+      latestAccuracy = Math.round((correctQuestions / totalQuestions) * 100);
+      break;
+    }
+  }
+
+  if (latestAccuracy !== null) {
+    accuracyHistory.push({
+      date: new Date().toISOString(),
+      accuracy: latestAccuracy
+    });
+    // Keep last 10 entries
+    if (accuracyHistory.length > 10) {
+      accuracyHistory = accuracyHistory.slice(-10);
+    }
+    await writeJson(accuracyHistoryPath, accuracyHistory);
+  }
+
+  // Derive trend from last 3 entries
+  const recent = accuracyHistory.slice(-3);
+  let recentAccuracyTrend = 'stable';
+  if (recent.length >= 2) {
+    const first = recent[0].accuracy;
+    const last = recent[recent.length - 1].accuracy;
+    if (last >= first + 10) recentAccuracyTrend = 'improving';
+    else if (last <= first - 10) recentAccuracyTrend = 'declining';
+  }
+
+  // Update frustration topics based on mastery stats
+  const frustrationTopics = [];
+  const allMasteryPoints = [];
+  for (const chapter of chapters) {
+    const chapterPaths = chapterDataPaths(chapter.id);
+    const chapterMastery = await readJson(chapterPaths.mastery, null);
+    if (chapterMastery?.points) {
+      allMasteryPoints.push(...Object.values(chapterMastery.points));
+    }
+  }
+  for (const point of allMasteryPoints) {
+    if (point.status === 'needs_review' && (point.wrongCount || 0) >= 3) {
+      frustrationTopics.push(point.id);
+    }
+  }
+
+  const learningState = {
+    ...(profile.learningState || {}),
+    recentAccuracyTrend: recentAccuracyTrend || profile.learningState?.recentAccuracyTrend || 'stable',
+    frustrationTopics: frustrationTopics.slice(0, 5),
+    preferredPace: profile.learningState?.preferredPace || 'steady',
+    lastSessionFatigue: profile.learningState?.lastSessionFatigue || 'medium'
+  };
+
+  await writeJson(paths.profile, { ...profile, learningState, updatedAt: new Date().toISOString() });
+}