dsh-plugin-lookatstudy 0.11.0 → 0.11.1

package/lib/index.mjs

@@ -1,11 +1,25 @@
+import { n as inflateZlib } from "./inflate-DIKUrTRi.mjs";
+import { t as extractArticle } from "./html-article-C6nhqJbX.mjs";
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { basename, dirname, join, relative, sep } from "node:path";
 import z from "@deepseek-ai/schemastery";
 import { homedir } from "node:os";
 import { randomBytes } from "node:crypto";
-import { defineTool } from "@deepseek-ai/dsh-tools";
 import { readFile, readdir } from "node:fs/promises";
+import { defineTool } from "@deepseek-ai/dsh-tools";
 import https from "node:https";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
 //#region src/config.ts
 /**
 * Plugin configuration schema (Schemastery) for dsh-plugin-lookatstudy.
@@ -39,9 +53,27 @@ const Config = z.object({
 function escapeHtml(text) {
 	return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 }
-/** Render inline markup (code, bold, italic, links) over escaped text. */
+/** Render inline markup (code, bold, italic, links, images) over escaped text.
+* Image src allowlist: https?:// or data:image/ — folder imports inline local
+* images as data URLs (capped), GitHub imports reference jsDelivr; anything
+* else stays literal text (no broken relative images, no exotic schemes). */
 function inline(escaped) {
-	return escaped.replace(/`([^`]+)`/g, "<code>$1</code>").replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>").replace(/\*([^*]+)\*/g, "<em>$1</em>").replace(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g, "<a href=\"$2\" target=\"_blank\" rel=\"noreferrer\">$1</a>");
+	return escaped.replace(/`([^`]+)`/g, "<code>$1</code>").replace(/\*\*([^*]+)\*\*/g, "<strong>$1</strong>").replace(/\*([^*]+)\*/g, "<em>$1</em>").replace(/!\[([^\]]*)\]\((https?:\/\/[^)\s]+|data:image\/[^)\s]+)\)/g, (_m, alt, src) => `<img src="${src}" alt="${alt}" loading="lazy">`).replace(/\[([^\]]+)\]\((https?:\/\/[^)\s]+)\)/g, "<a href=\"$2\" target=\"_blank\" rel=\"noreferrer\">$1</a>");
+}
+/** Interleave one body with its translation, paragraph by paragraph (upstream
+* translation-layout "microsoft" semantics: original paragraph then its
+* translation as a quote, tight pairing for bilingual reading; length
+* mismatches append the remainder in order). Pure. */
+function renderBilingual(bodyMd, translationMd) {
+	const par = (md) => md.split(/\n\s*\n/).map((p) => p.trim()).filter((p) => p !== "");
+	const a = par(bodyMd);
+	const b = par(translationMd);
+	const out = [];
+	for (let i = 0; i < Math.max(a.length, b.length); i++) {
+		if (a[i] !== void 0) out.push(a[i]);
+		if (b[i] !== void 0) out.push(`> ${b[i].split("\n").join("\n> ")}`);
+	}
+	return out.join("\n\n");
 }
 /** True when the line opens a GFM table row (pipes with a delimiter row next). */
 function isTableRow(line) {
@@ -163,6 +195,44 @@ function renderMarkdown(md) {
 	return out.join("\n");
 }
 //#endregion
+//#region src/vendor/math-normalize.ts
+/**
+* math-normalize —— 数学记法归一(v0.19 数学渲染前置,纯函数)。
+*
+* `\(...\)` / `\[...\]` 是 LaTeX 的原生行内/行间记法,remark-math 只认 `$`/
+* `$$`。导入的内容(AI 讲解/转写稿/粘贴文本)两种记法都可能出现,渲染前统一
+* 归一到 `$` 记法。幂等;**围栏代码块内不动**(代码里的 `\(` 是字面量)。
+*/
+function normalizeMathNotation(md) {
+	const out = [];
+	let inFence = false;
+	for (const line of md.split("\n")) {
+		if (/^[ \t]*(?:```|~~~)/.test(line)) {
+			out.push(line);
+			inFence = !inFence;
+			continue;
+		}
+		out.push(inFence ? line : line.replace(/\\\[|\\\]|\\\(|\\\)/g, (tok) => tok === "\\[" || tok === "\\]" ? "$$" : "$"));
+	}
+	return out.join("\n");
+}
+//#endregion
+//#region src/vendor/xp.ts
+/** Level curve (upstream): level = floor(sqrt(total/50)) — quadratic spans. */
+function levelFromTotalXp(totalXp) {
+	const safe = Math.max(0, Math.floor(totalXp));
+	const level = Math.floor(Math.sqrt(safe / 50));
+	const curStart = 50 * level * level;
+	const span = 50 * (level + 1) * (level + 1) - curStart;
+	const into = safe - curStart;
+	return {
+		level,
+		pct: span > 0 ? Math.min(100, Math.round(into / span * 100)) : 0,
+		intoLevel: into,
+		levelSpan: span
+	};
+}
+//#endregion
 //#region src/vendor/sm2.ts
 function computeSm2(prev, quality, now = /* @__PURE__ */ new Date()) {
 	let { easeFactor, intervalDays, repetitions } = prev;
@@ -227,6 +297,85 @@ function masteryToCrown(mastery) {
 	if (mastery < .9) return 4;
 	return 5;
 }
+/**
+* 题量规划:目标题数 = clamp(ceil(KC数 × 1.5), 5, 15),round-robin 分配到各 KC。
+* 返回与 kcTitles 等长的数组,每项 = 该 KC 出几题。
+* 例:4 KC → 6 题 [2,2,1,1];8 KC → 12 题 [2,2,2,2,1,1,1,1];12 KC → 15 题。
+*/
+function planExamQuota(kcTitles) {
+	const n = kcTitles.length;
+	if (n === 0) return [];
+	const target = Math.min(15, Math.max(5, Math.ceil(n * 3 / 2)));
+	const quotas = Array.from({ length: n }, () => 0);
+	for (let i = 0; i < target; i++) quotas[i % n]++;
+	return quotas;
+}
+/** 正确率 → 星数(1-3)。低于 60% 得 0 星(但会记录尝试)。 */
+function accuracyToStars(accuracy) {
+	if (accuracy >= .95) return 3;
+	if (accuracy >= .8) return 2;
+	if (accuracy >= .6) return 1;
+	return 0;
+}
+const MASTERED_MASTERY_THRESHOLD = .9;
+const NEAR_MASTERED_THRESHOLD = .85;
+/**
+* 答完题后的"下一步"动作集合。永远 >= 2 个动作(消灭死胡同)。
+* mark-mastered 只在"全对 + 高掌握度"时出现(避免误判掌握)。
+*/
+function getPostQuizActions(score, mastery) {
+	const { correct, total } = score;
+	const allCorrect = total > 0 && correct === total;
+	const hasWrong = total > 0 && correct < total;
+	const alreadyMastered = mastery != null && mastery >= MASTERED_MASTERY_THRESHOLD;
+	const nearMastered = mastery != null && mastery >= NEAR_MASTERED_THRESHOLD;
+	if (hasWrong) return [{ id: "explain-wrong" }, { id: "retry" }];
+	if (allCorrect && alreadyMastered) return [{ id: "next-topic" }, { id: "go-deeper" }];
+	if (allCorrect && nearMastered) return [
+		{
+			id: "mark-mastered",
+			advancesMastery: true
+		},
+		{ id: "next-topic" },
+		{ id: "go-deeper" }
+	];
+	return [{ id: "go-deeper" }, { id: "retry" }];
+}
+//#endregion
+//#region src/vendor/streak-transition.ts
+function todayStr(now = /* @__PURE__ */ new Date()) {
+	return `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+}
+function yesterdayStr(now = /* @__PURE__ */ new Date()) {
+	const y = new Date(now);
+	y.setDate(y.getDate() - 1);
+	return todayStr(y);
+}
+function daysBetween(a, b) {
+	const da = /* @__PURE__ */ new Date(a + "T00:00:00");
+	const db = /* @__PURE__ */ new Date(b + "T00:00:00");
+	return Math.round((db.getTime() - da.getTime()) / 864e5);
+}
+function computeStreakTransition(state, now = /* @__PURE__ */ new Date()) {
+	const today = todayStr(now);
+	const yesterday = yesterdayStr(now);
+	if (state.lastActiveDate === today) return state;
+	let newCurrent;
+	let newFreeze = state.freezeCount;
+	if (state.lastActiveDate === yesterday) newCurrent = state.currentStreak + 1;
+	else if (state.lastActiveDate === null) newCurrent = 1;
+	else if (daysBetween(state.lastActiveDate, today) === 2 && state.freezeCount > 0) {
+		newFreeze = state.freezeCount - 1;
+		newCurrent = state.currentStreak + 1;
+	} else newCurrent = 1;
+	const newLongest = Math.max(state.longestStreak, newCurrent);
+	return {
+		currentStreak: newCurrent,
+		longestStreak: newLongest,
+		lastActiveDate: today,
+		freezeCount: newFreeze
+	};
+}
 //#endregion
 //#region src/state.ts
 /**
@@ -254,7 +403,19 @@ function emptyState() {
 		memoryGlobal: null,
 		memoryPatterns: {},
 		proposals: [],
-		lessonSessions: {}
+		lessonSessions: {},
+		lastConsolidatedAt: null,
+		xp: {
+			total: 0,
+			todayKey: "",
+			todayXp: 0
+		},
+		streak: {
+			currentStreak: 0,
+			longestStreak: 0,
+			lastActiveDate: null,
+			freezeCount: 2
+		}
 	};
 }
 /**
@@ -315,7 +476,19 @@ function loadState(path) {
 		memoryGlobal: raw.memoryGlobal ?? null,
 		memoryPatterns: raw.memoryPatterns ?? {},
 		proposals: raw.proposals ?? [],
-		lessonSessions: raw.lessonSessions ?? {}
+		lessonSessions: raw.lessonSessions ?? {},
+		lastConsolidatedAt: raw.lastConsolidatedAt ?? null,
+		xp: raw.xp ?? {
+			total: 0,
+			todayKey: "",
+			todayXp: 0
+		},
+		streak: raw.streak ?? {
+			currentStreak: 0,
+			longestStreak: 0,
+			lastActiveDate: null,
+			freezeCount: 2
+		}
 	};
 }
 /**
@@ -384,7 +557,14 @@ function importCourse(state, parsed, source, sourceRef) {
 		sourceRef,
 		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
 		sections: parsed.sections.map((section) => {
-			const lessons = section.lessons.map((lesson) => freshLesson(lesson.title, lesson.anchor, lesson.body, lesson.world === "practice" ? "practice" : "study"));
+			const lessons = section.lessons.map((lesson) => (() => {
+				const st = freshLesson(lesson.title, lesson.anchor, lesson.body, lesson.world === "practice" ? "practice" : "study");
+				if (lesson.translation !== void 0) {
+					st.translation = lesson.translation;
+					st.translationLang = lesson.translationLang ?? "";
+				}
+				return st;
+			})());
 			if (section.world !== "practice" && lessons.filter((l) => l.kind === "study").length >= 2) lessons.push(freshLesson(`${section.title} · 章节测验`, `${section.anchor}#exam`, section.examBody ?? "", "exam"));
 			return {
 				title: section.title,
@@ -584,6 +764,28 @@ function attemptLesson(state, lessonId, now) {
 	};
 }
 /**
+* Record one graded exam attempt on an exam node: stars from accuracy
+* (upstream accuracyToStars thresholds), best-of retained across attempts
+* (upstream crownLevel-takes-max semantics). Study/practice lessons are
+* refused — this is the exam surface only.
+*/
+function recordExamResult(state, lessonId, correct, total) {
+	const ref = findLesson(state, lessonId);
+	if (ref.lesson.kind !== "exam") throw new Error(`lookatstudy-plugin: lesson ${JSON.stringify(lessonId)} is not an exam node — study_exam_result is for section exams`);
+	if (!Number.isInteger(correct) || !Number.isInteger(total) || total <= 0 || correct < 0 || correct > total) throw new Error(`lookatstudy-plugin: invalid exam score ${correct}/${total}`);
+	const stars = accuracyToStars(correct / total);
+	const prevBest = ref.lesson.examStars ?? -1;
+	ref.lesson.examStars = Math.max(prevBest, stars);
+	ref.lesson.examAttempts = (ref.lesson.examAttempts ?? 0) + 1;
+	ref.lesson.lastAnsweredAt = (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		ref,
+		stars,
+		bestStars: ref.lesson.examStars,
+		attempts: ref.lesson.examAttempts
+	};
+}
+/**
 * Record one graded answer against a lesson: attribute it to one knowledge
 * component when named, update BKT (per-KC, aggregated as the weakest),
 * nudge the SM-2 schedule when one exists, and apply mastery-driven
@@ -629,6 +831,7 @@ function recordAnswer(state, lessonId, correct, concept, now) {
 		ref.lesson.dueAt = result.dueAt;
 	}
 	const progression = applyProgression(ref, now);
+	const xp = noteXpActivity(state, progression.graduated ? 50 : correct ? 10 : 1, now);
 	return {
 		ref,
 		concept: kcIndex === void 0 ? null : {
@@ -639,7 +842,8 @@ function recordAnswer(state, lessonId, correct, concept, now) {
 		newMastery: ref.lesson.mastery ?? 0,
 		crown: masteryToCrown(ref.lesson.mastery),
 		mastered: (ref.lesson.mastery ?? 0) >= MASTERED_THRESHOLD,
-		progression
+		progression,
+		xp
 	};
 }
 /**
@@ -667,7 +871,7 @@ function completeLesson(state, lessonId, now) {
 * @param lessonId - lesson to describe.
 * @param concepts - 2–7 short concepts.
 */
-function defineConcepts(state, lessonId, concepts) {
+function defineConcepts(state, lessonId, concepts, summary) {
 	const ref = findLesson(state, lessonId);
 	if (concepts.length < 2 || concepts.length > 7) throw new Error(`lookatstudy-plugin: define 2–7 concepts (got ${concepts.length})`);
 	for (const def of concepts) if (def.title.trim() === "" || def.description.trim() === "") throw new Error("lookatstudy-plugin: every concept needs a non-empty title and description");
@@ -676,6 +880,7 @@ function defineConcepts(state, lessonId, concepts) {
 		description: c.description.trim()
 	}));
 	ref.lesson.conceptMastery = {};
+	if (summary !== void 0 && summary.trim() !== "") ref.lesson.summary = summary.trim();
 	aggregateMastery(ref.lesson);
 }
 /**
@@ -962,6 +1167,7 @@ function learnerSnapshot(state, now) {
 	return {
 		focus: ref === null ? null : {
 			lessonId: ref.lesson.id,
+			courseId: ref.course.id,
 			courseTitle: ref.course.title,
 			lessonTitle: ref.lesson.title,
 			masteryPct: ref.lesson.mastery === null ? null : Math.round(ref.lesson.mastery * 100),
@@ -985,6 +1191,125 @@ function tryFindLesson(state, lessonId) {
 		return null;
 	}
 }
+function gatherConsolidationWindow(state, capPerLesson = 10) {
+	const since = state.lastConsolidatedAt;
+	const entries = [];
+	let frictionCount = 0;
+	let practiceCount = 0;
+	for (const course of state.courses) for (const section of course.sections) for (const lesson of section.lessons) {
+		let perLesson = 0;
+		const collect = (kind, at, push) => {
+			if (since !== null && at <= since) return;
+			if (perLesson >= capPerLesson) return;
+			perLesson++;
+			push();
+		};
+		for (const f of lesson.friction) collect("friction", f.at, () => {
+			entries.push({
+				lessonId: lesson.id,
+				lessonTitle: lesson.title,
+				kind: "friction",
+				category: f.category,
+				text: f.summary ?? "(no summary)",
+				at: f.at
+			});
+			frictionCount++;
+		});
+		for (const n of lesson.notes) {
+			if (n.zone !== "practice") continue;
+			collect("practice", n.at, () => {
+				entries.push({
+					lessonId: lesson.id,
+					lessonTitle: lesson.title,
+					kind: "practice",
+					text: n.text.slice(0, 200),
+					at: n.at
+				});
+				practiceCount++;
+			});
+		}
+	}
+	entries.sort((a, b) => a.at < b.at ? -1 : a.at > b.at ? 1 : 0);
+	return {
+		since,
+		entries,
+		counts: {
+			friction: frictionCount,
+			practice: practiceCount
+		}
+	};
+}
+/**
+* Record one XP event + advance the streak (upstream xp-service addXp +
+* streak.ts applyStreak, state-ified). New-day rollover resets the today
+* bucket first. The streak transition runs on every XP event — activity IS
+* the check-in (upstream 打卡 semantics).
+*/
+function noteXpActivity(state, xp, now) {
+	const key = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, "0")}-${String(now.getDate()).padStart(2, "0")}`;
+	if (state.xp.todayKey !== key) {
+		state.xp.todayKey = key;
+		state.xp.todayXp = 0;
+	}
+	state.xp.total += xp;
+	state.xp.todayXp += xp;
+	state.streak = computeStreakTransition({
+		...state.streak,
+		lastActiveDate: state.streak.lastActiveDate ?? null
+	}, now);
+	return {
+		totalXp: state.xp.total,
+		todayXp: state.xp.todayXp,
+		streak: { ...state.streak }
+	};
+}
+function searchLessons(state, query, limit = 20) {
+	const keys = query.trim().toLowerCase().split(/\s+/).filter(Boolean);
+	if (keys.length === 0) return [];
+	const hits = [];
+	for (const course of state.courses) for (const section of course.sections) for (const lesson of section.lessons) {
+		const title = lesson.title.toLowerCase();
+		const body = lesson.body.toLowerCase();
+		if (!keys.every((k) => title.includes(k) || body.includes(k))) continue;
+		let snippet = lesson.body.replace(/\s+/g, " ").trim();
+		for (const k of keys) {
+			const idx = snippet.toLowerCase().indexOf(k);
+			if (idx >= 0) {
+				const start = Math.max(0, idx - 30);
+				snippet = (start > 0 ? "…" : "") + snippet.slice(start, start + 100) + (start + 100 < snippet.length ? "…" : "");
+				break;
+			}
+		}
+		hits.push({
+			courseId: course.id,
+			courseTitle: course.title,
+			lessonId: lesson.id,
+			lessonTitle: lesson.title,
+			snippet: snippet.slice(0, 120)
+		});
+		if (hits.length >= limit) return hits;
+	}
+	return hits;
+}
+/**
+* Serialize one course into a single markdown learning pack (upstream
+* pack-export's zero-LLS sharing semantics, dsh-adapted: the receiver imports
+* through the existing study_import_markdown — no new import path, no network).
+* Sections become ##, lessons ###, bodies verbatim; exam nodes keep their intro.
+* Pure.
+*/
+function courseToPackMarkdown(course) {
+	const parts = [`# ${course.title}`];
+	for (const section of course.sections) {
+		parts.push(`## ${section.title}`);
+		for (const lesson of section.lessons) {
+			if (lesson.kind === "exam") continue;
+			parts.push(`### ${lesson.title}`);
+			parts.push(lesson.body);
+		}
+	}
+	return parts.join("\n\n").trim() + "\n";
+}
 //#endregion
 //#region src/dashboard.ts
 /**
@@ -1055,7 +1380,8 @@ function workbenchState(state, now) {
 				source: n.source,
 				quote: n.quote
 			})),
-			html: renderMarkdown(ref.lesson.body)
+			html: renderMarkdown(normalizeMathNotation(ref.lesson.translation === void 0 ? ref.lesson.body : renderBilingual(ref.lesson.body, ref.lesson.translation))),
+			markdown: ref.lesson.body
 		};
 	} catch {
 		lesson = null;
@@ -1097,7 +1423,20 @@ function workbenchState(state, now) {
 				pattern: snap.memoryPattern
 			};
 		})(),
-		lessonSessions: state.lessonSessions
+		lessonSessions: state.lessonSessions,
+		progress: (() => {
+			const xp = levelFromTotalXp(state.xp.total);
+			return {
+				totalXp: state.xp.total,
+				level: xp.level,
+				levelPct: xp.pct,
+				todayXp: state.xp.todayXp,
+				dailyGoal: 30,
+				streak: state.streak.currentStreak,
+				longestStreak: state.streak.longestStreak,
+				freezeCount: state.streak.freezeCount
+			};
+		})()
 	};
 }
 const JSON_HEADERS = { "content-type": "application/json; charset=utf-8" };
@@ -1154,7 +1493,19 @@ function registerDashboard(webServer, deps) {
 		handler: async (req, res) => {
 			const pathname = new URL(req.url ?? "/", "http://x").pathname;
 			if (req.method === "GET" && pathname === "/lookatstudy/api/state") {
-				sendJson(res, 200, workbenchState(deps.store.get(), /* @__PURE__ */ new Date()));
+				sendJson(res, 200, {
+					...workbenchState(deps.store.get(), /* @__PURE__ */ new Date()),
+					statePath: deps.statePath
+				});
+				return;
+			}
+			if (req.method === "GET" && pathname === "/lookatstudy/api/search") {
+				const query = new URL(req.url ?? "/", "http://x").searchParams.get("q") ?? "";
+				sendJson(res, 200, {
+					ok: true,
+					query,
+					matches: searchLessons(deps.store.get(), query)
+				});
 				return;
 			}
 			if (req.method === "POST" && pathname === "/lookatstudy/api/active") {
@@ -1274,6 +1625,188 @@ function registerDashboard(webServer, deps) {
 	};
 }
 //#endregion
+//#region src/client/locale.ts
+/** Simplified Chinese dictionary (also the fallback locale). */
+const ZH = {
+	"tab.label": "学习",
+	"col.rail": "课程",
+	"col.tutor": "导师",
+	"col.bb": "黑板",
+	"pane.rail": "课程",
+	"pane.tutor": "导师",
+	"pane.bb": "黑板",
+	"viewtab.teach": "讲解",
+	"viewtab.mind": "🧠 脑图",
+	"viewtab.cmap": "🕸 概念图",
+	"viewtab.mind.title": "本课结构一图流(markmap)",
+	"viewtab.cmap.title": "本课概念关系(ELK 布局)",
+	"loading": "加载中…",
+	"start.title": "一键准备学习:建立学习工作区、开启会话并让导师就位",
+	"start.go": "开始学习",
+	"start.enter": "进入学习",
+	"start.busy": "正在准备学习区…",
+	"soul.direct": "直讲",
+	"soul.direct.hint": "direct 精讲:先讲清楚,再确认懂没懂",
+	"soul.guide": "引导",
+	"soul.guide.hint": "guide 引导:让你自己往前推一步,导师递台阶",
+	"soul.practice": "实战",
+	"soul.practice.hint": "practice 实战:在真实世界的乱问题里学",
+	"zone.understand": "🧠 理解区 — 知识结构",
+	"zone.record": "📝 记录区 — 我的话",
+	"zone.practice": "✍️ 练习区 — 答题日志",
+	"rail.empty.title": "暂无课程",
+	"rail.empty.hint": "粘贴 markdown → 说「导入为课程」",
+	"rail.empty.hint2": "本地文件夹 → 说「导入 D:/path/to/folder」",
+	"rail.empty.placeholder": "GitHub 仓库链接,如 microsoft/AI-For-Beginners",
+	"rail.empty.button": "导入",
+	"rail.empty.demo": "导入示例课程",
+	"rail.mastered": "{mastered}/{total} 已掌握",
+	"rail.avg": "平均掌握度 {pct}%",
+	"rail.avg.none": "尚无掌握度数据",
+	"rail.search": "搜索课时…(多关键词空格分隔)",
+	"rail.locate.title": "在课程树中定位当前焦点课时(自动展开所在章节)",
+	"rail.locate": "📍 回到当前课时",
+	"rail.due": "🔁 待复习 {count}",
+	"rail.due.over": "超{days}天",
+	"rail.due.start": "开始复习",
+	"rail.due.tag": "这课时的复习今天到期(SM-2)",
+	"rail.delete": "删除本课程",
+	"rail.delete.confirm": "确认删除?",
+	"rail.delete.title.confirm": "再点一次确认删除(含全部进度与笔记)",
+	"rail.section.collapse": "折叠本章节",
+	"rail.section.expand": "展开本章节({count} 课时)",
+	"rail.section.count": "{count} 课",
+	"rail.lesson.opening": "正在打开课时会话…",
+	"rail.import.toggle": "＋ 导入课程",
+	"rail.import.close": "收起导入",
+	"tag.weak": "{count} 个薄弱知识点,测验会优先考察",
+	"tag.friction": "{count} 次卡点记录(你说\"不懂\"时导师记下的)",
+	"tag.mastery": "课时掌握度 {pct}%(取最薄弱知识点)",
+	"tag.mastery.short": "课时掌握度 = 最薄弱知识点的掌握度",
+	"status.exam": "章节测验:本节全部课时掌握度 ≥50% 后开放",
+	"status.mastered": "已毕业:掌握度 ≥90%(或你接受了掌握提案)",
+	"status.in_progress": "学习中:已开课,掌握度从 50% 起步",
+	"status.available": "可开始:已解锁,尚未学习",
+	"status.locked": "未解锁:先完成前面的课时",
+	"chip.unattributed": "未归因",
+	"chip.correct": "✓ 答对 · {concept}",
+	"chip.wrong": "✗ 答错 · {concept}",
+	"chip.import": "📦 导入课程",
+	"chip.concepts": "🧠 提炼知识点",
+	"row.thinking": "导师思考中…",
+	"row.thinking.title": "导师正在推理,回复马上就来",
+	"quiz.title": "点击选项作答,也可以直接打字回答",
+	"quiz.answer": "选 {letter}:{text}",
+	"tutor.empty": "对话会出现在这里",
+	"tutor.empty.hint": "在下方输入框和导师说话",
+	"proposal.text": "导师提议你已掌握「{lesson}」:{rationale}",
+	"proposal.accept": "接受",
+	"proposal.decline": "再练练",
+	"bb.empty": "黑板还空着",
+	"bb.empty.hint": "在左侧课程树选择一课",
+	"bb.mastery": "掌握度 {pct}%",
+	"bb.fallback.mind": "脑图渲染不可用(网络受限) — 已回退讲解视图",
+	"bb.fallback.cmap.empty": "概念图需要先由导师定义本课概念",
+	"bb.fallback.cmap": "概念图渲染不可用(布局引擎加载失败) — 已回退讲解视图",
+	"bb.notes": "笔记",
+	"bb.notes.empty": "这一课还没有笔记",
+	"active.off.title": "注册 study 工具并载入导师人格,之后普通对话和现在一样",
+	"active.on.title": "注销 study 工具与导师人格;学习进度保留,可随时重新开启",
+	"active.off": "▶ 开始学习",
+	"active.on": "⏻ 退出学习模式",
+	"prompt.kickoff": "开始学习:查看我的学习状态并打开当前焦点课时。如果我还没有课程,推荐我导入示例课程(AI-For-Beginners)并说明怎么开始。回复最后请提醒我点上方「学习」页签进入学习界面。",
+	"settings.nav": "学习",
+	"settings.mode": "教学风格",
+	"settings.mode.hint": "导师的讲解风格;也可在学习页随时切换",
+	"settings.studyMode": "学习模式",
+	"settings.studyMode.hint": "开启后注册 study_* 工具并载入导师人格;进度与笔记始终保留",
+	"settings.on": "已开启",
+	"settings.off": "已关闭",
+	"settings.turnOn": "开启",
+	"settings.turnOff": "关闭",
+	"settings.stats": "学习统计",
+	"settings.stats.courses": "课程 {count} 个",
+	"settings.stats.xp": "XP {xp} · Lv{level}({pct}%)",
+	"settings.stats.today": "今日 {xp}/{goal}",
+	"settings.stats.streak": "连续 {days} 天(最长 {best},剩冻结 {freeze})",
+	"settings.stateFile": "状态文件",
+	"settings.stateFile.hint": "学习进度存放于本机 JSON,换机可迁移",
+	"dock.title": "学习状态:待复习 {due} · 连续 {streak} 天 · Lv{level} — 点上方「学习」页签进入",
+	"dock.due": "⚡{count}",
+	"dock.streak": "🔥{days}d",
+	"dock.lv": "Lv{level}",
+	"prompt.import": "导入课程:用 study_import_github 抓取 {url}",
+	"prompt.lesson": "学习「{title}」:用 study_lesson 打开这一课开始学习。",
+	"prompt.exam": "开始「{section}」的章节测验:按本节课时出题,答完逐题判分",
+	"prompt.review": "开始今天的复习,从最到期的课时开始",
+	"prompt.proposal.accept": "接受提案 {id} —— 确认标记这课为已掌握",
+	"prompt.proposal.decline": "拒绝提案 {id} —— 我想再练练"
+};
+//#endregion
+//#region src/commands.ts
+/**
+* The `/study` slash command (host side): the keyboard/headless discovery
+* path into the study surface. Bare `/study` activates a dormant install and
+* queues the same kickoff prompt the hero button sends; `/study <text>`
+* queues that text as the learning request. Activation follows the exact
+* dashboard route's semantics (persist + tool-registry sync BEFORE the
+* prompt lands), so the model the prompt meets can already call the tools.
+*
+* Structural slices of the harness command contract keep this module free of
+* a new peer dependency; `agent.followup` is the model-visible user-message
+* path (the /goal command's attachment precedent).
+* @module dsh-plugin-lookatstudy/commands
+*/
+/** Build one identified user message (createUserMessage's structural twin: uuid + freeze). */
+function userMessage(text) {
+	const content = Object.freeze([{
+		type: "text",
+		text
+	}]);
+	return Object.freeze({
+		id: crypto.randomUUID(),
+		role: "user",
+		content,
+		source: Object.freeze({
+			kind: "plugin",
+			plugin: "dsh-plugin-lookatstudy"
+		})
+	});
+}
+/** The model-facing kickoff (the hero button's prompt; the tutor replies in the learner's own language). */
+function studyKickoffPrompt() {
+	return ZH["prompt.kickoff"];
+}
+/** Execute `/study [<text>]` against the live store. Pure over the deps; no HTTP. */
+function executeStudyCommand(deps, invocation) {
+	const state = deps.store.get();
+	if (!state.active) {
+		state.active = true;
+		deps.store.save();
+		deps.onActiveChange(true);
+	}
+	const text = invocation.rawInput.trim() === "" ? studyKickoffPrompt() : invocation.rawInput.trim();
+	invocation.agent.followup(userMessage(text));
+	return {
+		kind: "success",
+		text: "学习模式已就位 — 回复马上开始;点上方「学习」页签进入学习界面 / Study mode is on — open the Study tab above for the study UI."
+	};
+}
+/**
+* Register `/study` on the harness command runtime (global scope).
+* @param commands - the host `commands` service.
+* @param deps - the shared store wiring.
+* @returns the registration disposer.
+*/
+function registerStudyCommand(commands, deps) {
+	return commands.register({
+		name: "study",
+		description: "start (or resume) a guided study session — activates the tutor and queues the kickoff prompt",
+		input: { hint: "[<learning request>]" },
+		handler: (invocation) => executeStudyCommand(deps, invocation)
+	});
+}
+//#endregion
 //#region src/vendor/markdown-course.ts
 /**
 * GitHub 风格的 anchor 生成：小写、去一组标点（保留中文等 unicode）、每个空格单独转 -。
@@ -1281,7 +1814,7 @@ function registerDashboard(webServer, deps) {
 * 与 seed.ts 的锚点对齐。
 */
 function titleToAnchor(title) {
-	return title.toLowerCase().trim().replace(/[!"#$%&'()*+,.\/:;<=>?@[\\\]^`{|}~]/g, "").replace(/ /g, "-").replace(/^-|-$/g, "");
+	return title.toLowerCase().trim().replace(/[!"#$%&'()*+,./:;<=>?@[\\\]^`{|}~]/g, "").replace(/ /g, "-").replace(/^-|-$/g, "");
 }
 /**
 * 清洗课时/章节标题 — 去 emoji、多余空格、markdown 格式符号。
@@ -1289,7 +1822,7 @@ function titleToAnchor(title) {
 * "## [Pre-lecture quiz](url)" → "Pre-lecture quiz"
 */
 function cleanTitle(raw) {
-	return raw.replace(/[\u{1F000}-\u{1FFFF}\u{2600}-\u{27BF}\u{2190}-\u{21FF}\u{2B00}-\u{2BFF}]/gu, "").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/^#+\s*/, "").trim().replace(/\s+/g, " ").replace(/^[·\-\.\s]+|[·\-\.\s]+$/g, "").trim();
+	return raw.replace(/[\u{1F000}-\u{1FFFF}\u{2600}-\u{27BF}\u{2190}-\u{21FF}\u{2B00}-\u{2BFF}]/gu, "").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/^#+\s*/, "").trim().replace(/\s+/g, " ").replace(/^[·\-.\s]+|[·\-.\s]+$/g, "").trim();
 }
 /**
 * 解析 markdown 为课程树。
@@ -1384,6 +1917,8 @@ const EXT_KIND = {
 	htm: "html",
 	pdf: "pdf",
 	pptx: "pptx",
+	epub: "epub",
+	docx: "docx",
 	ipynb: "ipynb",
 	rst: "rst",
 	rmd: "rmd",
@@ -1555,7 +2090,7 @@ async function scanFolder(rootDir, onProgress, options) {
 		const kind = EXT_KIND[ext];
 		if (!kind) continue;
 		try {
-			const content = await readFileWithKind(f.absPath, kind);
+			const content = await readFileWithKind(f.absPath, kind, options?.parsePdf);
 			if (!content || content.trim().length < 5) continue;
 			const lang = detectLang(f.relPath);
 			docs.push({
@@ -1620,9 +2155,9 @@ async function scanFolder(rootDir, onProgress, options) {
 	for (const doc of dedupedDocs) {
 		if (doc.kind !== "pptx") continue;
 		try {
-			const { parsePptx } = await import("../lib/pptx-parser.js");
+			const { parsePptx } = await import("./pptx-parser-CD5pR2cj.mjs");
 			const result = await parsePptx(await readFile(join(rootDir, doc.path)));
-			for (const img of result.images) pptxImages.push({
+			for (const img of result.images ?? []) pptxImages.push({
 				path: `${doc.path}#slide${img.slideNumber}.png`,
 				absPath: "",
 				title: `${doc.title} - 图(第${img.slideNumber}页)`,
@@ -1802,17 +2337,28 @@ async function walkDir(root, current, acc) {
 		}
 	}
 }
-async function readFileWithKind(absPath, kind) {
+async function readFileWithKind(absPath, kind, parsePdf) {
 	if (kind === "pdf") {
 		const buf = await readFile(absPath);
-		const { parsePdfText } = await import("../lib/pdf-text.js");
+		if (parsePdf) return parsePdf(buf);
+		const { parsePdfText } = await Promise.resolve().then(() => pdf_text_exports);
 		return parsePdfText(buf);
 	}
 	if (kind === "pptx") {
 		const buf = await readFile(absPath);
-		const { parsePptx } = await import("../lib/pptx-parser.js");
+		const { parsePptx } = await import("./pptx-parser-CD5pR2cj.mjs");
 		return (await parsePptx(buf)).markdown;
 	}
+	if (kind === "docx") {
+		const buf = await readFile(absPath);
+		const { parseDocx } = await import("./docx-parser-BhyqPImb.mjs");
+		return parseDocx(buf).replace(/^(#{1,5}) /gm, (m) => `#${m}`);
+	}
+	if (kind === "epub") {
+		const buf = await readFile(absPath);
+		const { parseEpubFlat } = await import("./epub-parser-DvlKap-d.mjs");
+		return parseEpubFlat(buf);
+	}
 	if (kind === "ipynb") {
 		const raw = await readFile(absPath, "utf8");
 		const { parseNotebook } = await import("./notebook-parser-ChbZBIKJ.mjs");
@@ -1859,6 +2405,121 @@ function naturalPathCompare(a, b) {
 	}
 	return pa.length - pb.length;
 }
+/**
+* 为新管线构建本地清点:scanFolder + translations + README + fullTree + standaloneImages。
+*
+* 和 GitHub 的 fetchRepoInventory 对齐:产出 readmeMd + fileList(隐含在 docs 里) +
+* fullTree,供 classifyFileRoles + designCourseStructure 使用。
+*/
+async function buildLocalInventory(rootDir, onProgress, options) {
+	const scanResult = await scanFolder(rootDir, onProgress, {
+		collectImages: true,
+		parsePdf: options?.parsePdf
+	});
+	const { docs, images } = Array.isArray(scanResult) ? {
+		docs: scanResult,
+		images: []
+	} : scanResult;
+	const { translations, translationLangs } = await scanTranslationsDir(rootDir);
+	return {
+		docs,
+		images,
+		translations,
+		translationLangs,
+		readmeMd: findReadmeContent(docs),
+		fullTree: [
+			...docs.map((d) => d.path),
+			...images.map((i) => i.path),
+			...translations.map((t) => t.path)
+		],
+		standaloneImages: findStandaloneImages(images, docs)
+	};
+}
+/**
+* 扫描 translations/{lang}/ 目录。
+* 每个 lang 子目录对应一种翻译语言,其下的文件按原目录结构保留。
+* path = translations/{lang}/{相对 lang 目录的路径}。
+*/
+async function scanTranslationsDir(rootDir) {
+	const translationsDir = join(rootDir, "translations");
+	if (!existsSync(translationsDir)) return {
+		translations: [],
+		translationLangs: []
+	};
+	let langEntries;
+	try {
+		langEntries = await readdir(translationsDir, { withFileTypes: true });
+	} catch {
+		return {
+			translations: [],
+			translationLangs: []
+		};
+	}
+	const langs = langEntries.filter((e) => e.isDirectory()).map((e) => e.name);
+	const translations = [];
+	for (const lang of langs) {
+		const langDir = join(translationsDir, lang);
+		const transFiles = [];
+		await walkDir(langDir, langDir, transFiles);
+		for (const f of transFiles) {
+			if (f.isImage) continue;
+			const ext = f.relPath.toLowerCase().match(/\.([^.]+)$/)?.[1] ?? "";
+			const kind = EXT_KIND[ext];
+			if (!kind) continue;
+			try {
+				const content = await readFileWithKind(f.absPath, kind);
+				if (!content || content.trim().length < 5) continue;
+				translations.push({
+					path: `translations/${lang}/${f.relPath}`,
+					title: inferTitle(f.relPath),
+					content,
+					lang: detectLang(f.relPath),
+					kind
+				});
+			} catch {}
+		}
+	}
+	return {
+		translations,
+		translationLangs: langs
+	};
+}
+/**
+* 从已扫描文档里找 README 全文。
+* 优先根目录 README.md/README.markdown,其次 index.md,再首个 md,都没有返回 ""。
+*/
+function findReadmeContent(docs) {
+	const readme = docs.find((d) => {
+		const parts = d.path.split("/");
+		return parts.length === 1 && /^readme\.(md|markdown)$/i.test(parts[0]);
+	});
+	if (readme) return readme.content;
+	const index = docs.find((d) => {
+		const parts = d.path.split("/");
+		return parts.length === 1 && /^index\.(md|markdown)$/i.test(parts[0]);
+	});
+	if (index) return index.content;
+	return docs.find((d) => d.kind === "md")?.content ?? "";
+}
+/**
+* 找出不被任何文档引用的独立图片文件。
+* 这些是"孤儿"图片,需要 LLM 在 Step 4 关联到最相关的 lesson。
+*
+* 判定:source=image_file(独立文件,非 PDF/notebook 提取) + 有 absPath(磁盘文件) +
+*      不在任何文档的图片引用路径里。
+*/
+function findStandaloneImages(images, docs) {
+	const referencedPaths = /* @__PURE__ */ new Set();
+	for (const doc of docs) {
+		if (doc.kind === "txt" || doc.kind === "html") continue;
+		const refs = extractImageRefs(doc.content);
+		for (const ref of refs) {
+			const resolved = resolveImageRef(ref.refPath, doc.path);
+			referencedPaths.add(resolved);
+		}
+	}
+	return images.filter((img) => img.source === "image_file" && img.absPath && !referencedPaths.has(img.path));
+}
 //#endregion
 //#region src/vendor/repo-fetcher.ts
 /** CDN URL 构造 */
@@ -2251,6 +2912,34 @@ async function fetchRepoInventory(owner, repo, branch, fetchFn, onProgress, sign
 	};
 }
 /**
+* 提取正文开头摘录(供 Step 4 结构设计做语义分组)。
+*
+* 规则:
+*   - 跳过标题行(#/##/###)、代码围栏内容、空行、纯符号行(分隔线/表格线)
+*   - 行内 markdown 降噪:图片整体丢弃、`[文字](链接)` 只留文字、剥引用前缀 ">"
+*   - 行以空格连接成单行(进 prompt 的 JSON 块不能带换行),空白折叠
+*   - 攒够 maxChars 即停(长文件不读完,零浪费)
+* 纯函数,可 verify 直测。
+*/
+function extractBodyPreview(text, maxChars = 300) {
+	const lines = text.split(/\r?\n/);
+	let inCodeFence = false;
+	let buf = "";
+	for (const rawLine of lines) {
+		if (buf.length >= maxChars) break;
+		if (/^(\s*)(```|~~~)/.test(rawLine)) {
+			inCodeFence = !inCodeFence;
+			continue;
+		}
+		if (inCodeFence) continue;
+		if (/^#{1,6}\s/.test(rawLine)) continue;
+		let line = rawLine.replace(/!\[[^\]]*\]\([^)]*\)/g, "").replace(/\[([^\]]*)\]\([^)]*\)/g, "$1").replace(/^>\s?/, "").replace(/\s+/g, " ").trim();
+		if (!line || /^(-{3,}|\*{3,}|_{3,})$/.test(line) || /^\|?[\s:|-]+\|?$/.test(line)) continue;
+		buf += (buf ? " " : "") + line;
+	}
+	return buf.slice(0, maxChars);
+}
+/**
 * Step 3: 批量提取文件的标题大纲（H1/H2/H3 + 每段字符数，不含正文）。
 * 拉取完整文件文本（不只前 N 行），因为字符数统计需要全文。
 * 并发度 5，同 fetchMarkdownContents。
@@ -2345,7 +3034,8 @@ function extractOutlineWithCharCounts(text, filePath) {
 	return {
 		h1: h1 || (filePath.split("/").pop() ?? filePath),
 		totalChars,
-		headings
+		headings,
+		bodyPreview: extractBodyPreview(text)
 	};
 }
 /**
@@ -2390,6 +3080,324 @@ async function fetchSingleFileContent(filePath, owner, repo, branch, fetchFn) {
 	}
 }
 /**
+* 通用二进制下载(arXiv PDF 等):注入 fetchFn(跟随重定向),带取消与
+* 大小上限。fetchImageAsDataUrl 的泛化——那个只管 CDN 图片且吞错,这个要把
+* 失败原因如实抛给用户。
+*/
+async function downloadToBuffer(url, fetchFn, opts = {}) {
+	const maxBytes = opts.maxBytes ?? 67108864;
+	const r = await fetchFn(url, {
+		signal: opts.signal,
+		headers: opts.headers
+	});
+	if (!r.ok) throw new Error(`下载失败(HTTP ${r.status}):${url}`);
+	const buf = Buffer.from(await r.arrayBuffer());
+	if (buf.length === 0) throw new Error(`下载内容为空:${url}`);
+	if (buf.length > maxBytes) throw new Error(`文件超过 ${Math.round(maxBytes / 1024 / 1024)}MB 上限,放弃导入`);
+	return buf;
+}
+//#endregion
+//#region src/vendor/import-plan.ts
+/** 从 GitHub URL 提取 owner/repo;无效返回 null(与 IPC 旧正则一致,.git 后缀剥掉)。 */
+function parseGithubUrl$1(url) {
+	const m = url.match(/github\.com\/([^/]+)\/([^/]+)/);
+	if (!m) return null;
+	return {
+		owner: m[1],
+		repo: m[2].replace(/\.git$/, "")
+	};
+}
+//#endregion
+//#region src/vendor/url-route.ts
+/**
+* 智能 URL 路由 —— 一个输入框自动分流三类导入来源(纯函数)。
+*
+*   github.com/{owner}/{repo} → 走既有仓库导入(完整 5 步管线)
+*   arxiv.org / export.arxiv.org 的 /abs/ID 或 /pdf/ID → 论文 PDF 导入
+*   其余任意 http(s) → 网页文章正文抽取(readability)
+*
+* 用户不需要理解三种来源的区别。纯函数,verify 直测。
+*/
+/** arXiv 论文 ID:新式 2401.12345[v2] / 旧式 cs.CL/24010000 / hep-th/9901001 */
+const ARXIV_ID = /^[a-z.-]+\/\d{7}$|^\d{4}\.\d{4,5}(v\d+)?$/i;
+function routeImportUrl(raw) {
+	const url = raw.trim();
+	if (!url || /\s/.test(url)) return null;
+	if (parseGithubUrl$1(url)) return {
+		kind: "github",
+		url
+	};
+	if (url.includes("://") && !/^https?:\/\//i.test(url)) return null;
+	let parsed;
+	try {
+		parsed = new URL(/^https?:\/\//i.test(url) ? url : `https://${url}`);
+	} catch {
+		return null;
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return null;
+	const host = parsed.hostname.toLowerCase().replace(/^www\./, "");
+	if (host === "arxiv.org" || host === "export.arxiv.org") {
+		const id = parsed.pathname.match(/^\/(?:abs|pdf)\/([^?#]+?)(?:\.pdf)?$/i)?.[1] ?? "";
+		if (id && ARXIV_ID.test(id)) return {
+			kind: "url",
+			flavor: "arxiv",
+			url: `https://arxiv.org/abs/${id}`,
+			arxivId: id,
+			pdfUrl: `https://export.arxiv.org/pdf/${id}`
+		};
+	}
+	const path = parsed.pathname;
+	if (host === "bilibili.com" || host === "b23.tv") {
+		if (/(BV[a-zA-Z0-9]+|av\d+)/i.test(path) || host === "b23.tv" || path.startsWith("/video/")) return {
+			kind: "video",
+			source: "bilibili",
+			url: parsed.toString()
+		};
+	}
+	if (host === "douyin.com" || host === "v.douyin.com" || host === "iesdouyin.com") return {
+		kind: "video",
+		source: "ytdlp",
+		url: parsed.toString()
+	};
+	if (host === "youtube.com" || host === "youtu.be" || host === "m.youtube.com") {
+		if (host === "youtu.be" || path === "/watch" || path.startsWith("/shorts/") || path.startsWith("/live/")) return {
+			kind: "video",
+			source: "ytdlp",
+			url: parsed.toString()
+		};
+	}
+	return {
+		kind: "url",
+		flavor: "article",
+		url: parsed.toString()
+	};
+}
+/** 身份键用:归一化 URL(去 hash,去尾斜杠;query 保留——不少站点 query 载内容)。 */
+function normalizeUrlIdentity(url) {
+	try {
+		const u = new URL(url);
+		u.hash = "";
+		return u.toString().replace(/\/$/, "");
+	} catch {
+		return url;
+	}
+}
+//#endregion
+//#region src/vendor/pdf-text.ts
+var pdf_text_exports = /* @__PURE__ */ __exportAll({ parsePdfText: () => parsePdfText });
+function decodePdfString(s) {
+	return s.replace(/\\([0-7]{1,3}|.)/g, (_m, esc) => {
+		if (/^[0-7]+$/.test(esc)) return String.fromCharCode(parseInt(esc, 8));
+		if (esc === "n") return "\n";
+		if (esc === "r") return "\r";
+		if (esc === "t") return "	";
+		if (esc === "b" || esc === "f") return " ";
+		return esc;
+	});
+}
+function decodeHexString(s) {
+	const clean = s.replace(/[^0-9a-fA-F]/g, "");
+	let out = "";
+	const bytes = [];
+	for (let i = 0; i + 1 < clean.length; i += 2) bytes.push(parseInt(clean.slice(i, i + 2), 16));
+	if (bytes.length >= 2 && bytes[0] === 254 && bytes[1] === 255) {
+		for (let i = 2; i + 1 < bytes.length; i += 2) out += String.fromCharCode(bytes[i] << 8 | bytes[i + 1]);
+		return out;
+	}
+	for (const b of bytes) if (b >= 32 && b < 127) out += String.fromCharCode(b);
+	return out;
+}
+/** Pull text out of one decoded content stream. */
+function textFromContentStream(content) {
+	if (!/BT[\s\S]*?ET/.test(content)) return "";
+	let out = "";
+	const re = /\(((?:\\.|[^\\()])*)\)\s*(Tj|'|")|<([0-9a-fA-F\s]+)>\s*(Tj|'|")|\[((?:\(.*?\)|<[0-9a-fA-F\s]+>|[^\]])*?)\]\s*TJ/g;
+	let m;
+	while ((m = re.exec(content)) !== null) if (m[1] !== void 0) {
+		out += decodePdfString(m[1]);
+		if (m[2] === "'" || m[2] === "\"") out += "\n";
+	} else if (m[3] !== void 0) {
+		out += decodeHexString(m[3]);
+		if (m[4] === "'" || m[4] === "\"") out += "\n";
+	} else if (m[5] !== void 0) {
+		const partRe = /\(((?:\\.|[^\\()])*)\)|<([0-9a-fA-F\s]+)>/g;
+		let pm;
+		while ((pm = partRe.exec(m[5])) !== null) out += pm[1] !== void 0 ? decodePdfString(pm[1]) : decodeHexString(pm[2] ?? "");
+	}
+	return out;
+}
+/**
+* PDF 文本层抽取(零依赖)。逐个 stream 对象:Flate 解压 → BT/ET 块内 Tj/TJ 文本。
+* 顺序按对象在文件中的出现位置(绝大多数生成器按页序写)。
+* 限制(诚实):加密 PDF、纯扫描图、Type0 复合字体编码的 PDF 返回部分或空文本;
+* 调用方按"无文本"处理,不让单个 PDF 崩掉导入(同上游契约)。
+*/
+function parsePdfText(buf) {
+	const latin = new TextDecoder("latin1");
+	const raw = latin.decode(buf);
+	if (/\/Encrypt\b/.test(raw)) return "";
+	const parts = [];
+	const streamRe = /stream\r?\n?/g;
+	let sm;
+	while ((sm = streamRe.exec(raw)) !== null) {
+		const start = sm.index + sm[0].length;
+		const end = raw.indexOf("endstream", start);
+		if (end === -1) break;
+		const head = raw.slice(Math.max(0, sm.index - 300), sm.index);
+		if (!/obj\b[\s\S]*<<[\s\S]*>>\s*$/.test(head) && !/<<[^<>]*>>\s*$/.test(head)) continue;
+		const chunk = buf.subarray(start, end);
+		let content = "";
+		if (/FlateDecode/.test(head)) try {
+			content = latin.decode(inflateZlib(chunk));
+		} catch {
+			streamRe.lastIndex = end + 9;
+			continue;
+		}
+		else if (!/\/Filter/.test(head)) content = latin.decode(chunk);
+		else {
+			streamRe.lastIndex = end + 9;
+			continue;
+		}
+		const text = textFromContentStream(content);
+		if (text.trim()) parts.push(text);
+		streamRe.lastIndex = end + 9;
+	}
+	return parts.join("\n").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+//#endregion
+//#region src/vendor/text-chunk.ts
+/** 段落/句子边界切分:优先段落聚合,超长段落内再按句子切。 */
+function splitToUnits(text) {
+	const units = [];
+	for (const para of text.split(/\n{2,}/)) {
+		const p = para.replace(/\s+/g, " ").trim();
+		if (!p) continue;
+		if (p.length <= 600) {
+			units.push(p);
+			continue;
+		}
+		const sentences = p.match(/[^。！？!?.]+[。！？!?.]+["'”’）)]*|[^。！？!?.]+$/g) ?? [p];
+		for (const s of sentences) {
+			const t = s.trim();
+			if (t) units.push(t);
+		}
+	}
+	return units;
+}
+/**
+* 把无标题长文切成多个虚拟 markdown 文件。
+* @param stem 虚拟文件名主干(如 "notes" / "arxiv-2401.12345"),产出 {stem}-01.md
+* @param targetChars 每段目标字符数(默认 4000,与 Step4 的 3000-8000 课时段对齐)
+*/
+function chunkHeadinglessText(text, stem, targetChars = 4e3) {
+	const cleaned = text.replace(/\r\n/g, "\n").trim();
+	if (!cleaned) return [];
+	const units = splitToUnits(cleaned);
+	const chunks = [];
+	let buf = [];
+	let bufLen = 0;
+	for (const u of units) {
+		if (u.length > targetChars) {
+			if (buf.length > 0) {
+				chunks.push(buf.join("\n\n"));
+				buf = [];
+				bufLen = 0;
+			}
+			for (let i = 0; i < u.length; i += targetChars) chunks.push(u.slice(i, i + targetChars));
+			continue;
+		}
+		if (bufLen + u.length > targetChars && buf.length > 0) {
+			chunks.push(buf.join("\n\n"));
+			buf = [];
+			bufLen = 0;
+		}
+		buf.push(u);
+		bufLen += u.length;
+	}
+	if (buf.length > 0) chunks.push(buf.join("\n\n"));
+	return chunks.map((c, i) => {
+		return {
+			path: `${stem}-${String(i + 1).padStart(2, "0")}.md`,
+			content: `# 第 ${i + 1} 部分\n\n${c}`
+		};
+	});
+}
+/**
+* 单一长文档的统一预处理器:有 H2/H3 结构 → 整体一个文件(Step4 自己按标题拆);
+* 无结构且超长 → chunkHeadinglessText 预分段。url/arXiv/粘贴三个来源共用。
+*/
+function prepareSingleDoc(name, markdown, stem) {
+	const md = markdown.trim();
+	if (!md) return [];
+	if ((md.match(/^##\s/m) ?? []).length >= 3 || md.length <= 8e3) return [{
+		path: `${name.replace(/[\\/:*?"<>|#]/g, "-").trim() || "document"}.md`,
+		content: md
+	}];
+	return chunkHeadinglessText(md, (stem ?? name.replace(/\s+/g, "-").slice(0, 40)) || "text");
+}
+//#endregion
+//#region src/vendor/video-meta.ts
+const BILI_HEADERS = {
+	"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0 Safari/537.36",
+	Referer: "https://www.bilibili.com/"
+};
+/** 从 B站 URL 提取 BV/av 号与分P(b23.tv 短链由 fetchFn 跟随重定向展开)。
+*  page=undefined 表示 URL 未带 ?p= —— 多分P 视频导入整季;带 ?p=N 只导该集。 */
+function parseBilibiliId(url) {
+	const m = (url.match(/bilibili\.com\/(?:video\/)?(?:BV[a-zA-Z0-9]+|av\d+)/i) ? url : null)?.match(/(BV[a-zA-Z0-9]+|av(\d+))/i);
+	if (!m) return null;
+	const pm = url.match(/[?&]p=(\d+)/);
+	return {
+		bvid: m[1].toLowerCase().startsWith("bv") ? m[1] : void 0,
+		aid: m[2] ? Number(m[2]) : void 0,
+		page: pm ? Math.max(1, Number(pm[1])) : void 0
+	};
+}
+/** view API 元数据(免登录,无 wbi)。b23.tv 短链由 fetchFn 重定向展开后重试一次。 */
+async function fetchBilibiliMeta(url, fetchFn, signal) {
+	let id = parseBilibiliId(url);
+	if (!id && /b23\.tv/i.test(url)) id = parseBilibiliId((await fetchFn(url, {
+		signal,
+		headers: BILI_HEADERS
+	})).url);
+	if (!id) throw new Error("不是可识别的 B站视频链接(BV/av 号缺失)");
+	const resp = await (await fetchFn(`https://api.bilibili.com/x/web-interface/view?${id.bvid ? `bvid=${id.bvid}` : `aid=${id.aid}`}`, {
+		signal,
+		headers: BILI_HEADERS
+	})).json();
+	if (resp.code !== 0 || !resp.data) throw new Error(`B站接口返回错误(${resp.code} ${resp.message ?? ""})`);
+	const d = resp.data;
+	return {
+		title: (d.title ?? "").trim() || "未命名视频",
+		owner: (d.owner?.name ?? "").trim(),
+		desc: (d.desc ?? "").trim(),
+		parts: (d.pages ?? []).map((p) => (p.part ?? "").trim()).filter(Boolean),
+		duration: d.duration ?? 0
+	};
+}
+//#endregion
+//#region src/vendor/token-estimate.ts
+/**
+* token 用量估算 —— main 与 renderer 共用的纯启发式(零依赖,不引 tokenizer)。
+*
+* 为什么是启发式:本地优先 + 无原生模块约束(sql.js/Electron),而上下文表只需要
+* "约 x%"的量级感,不需要精确计费。标尺来自主流 tokenizer 的经验值:
+*   - CJK 字符 ≈ 1.1 token/字(o200k/cl100k 对常用汉字 1-2 token,均值取 1.1)
+*   - 其他(拉丁/代码/符号) ≈ 4 字符/token
+*
+* 纯函数:确定性、可测(verify-token-estimate.mjs)。
+*/
+/** CJK 及全角区段(含 CJK 标点/全角 ASCII/假名/谚文边缘),命中即按"一字一 token 档"计。 */
+const CJK_RE = /[\u2E80-\u9FFF\uF900-\uFAFF\u3000-\u303F\uFF00-\uFFEF]/g;
+/** 估算一段文本的 token 数。空串返回 0;只向上取整。
+* CJK 用整数算术(×11/10)避开 0.1 的浮点误差,100 字恰好 110 而非 111。 */
+function estimateTokens(text) {
+	if (!text) return 0;
+	const cjk = (text.match(CJK_RE) ?? []).length;
+	const other = text.length - cjk;
+	return Math.ceil(cjk * 11 / 10 + other / 4);
+}
+/**
 * Build the pending design from Step 1 (inventory) + Step 3 (outlines).
 * @param url - the GitHub URL the learner asked to import.
 * @param owner - repo owner.
@@ -2430,7 +3438,7 @@ function buildPendingDesign(url, owner, repo, inventory, outlines) {
 * @param docs - scanFolder output (relative paths + content).
 * @returns the pending design.
 */
-function buildPendingDesignFromFolder(path, title, docs) {
+function buildPendingDesignFromFolder(path, title, docs, extra) {
 	const files = docs.map((doc) => ({
 		path: doc.path,
 		role: doc.kind === "ipynb" ? "practice" : "original",
@@ -2449,28 +3457,112 @@ function buildPendingDesignFromFolder(path, title, docs) {
 		readmeExcerpt: readme.slice(0, 4e3),
 		files,
 		fullTreeCount: docs.length,
-		localContents
+		localContents,
+		...extra?.translations !== void 0 && extra.translations.length > 0 ? { translations: collectTranslations(extra.translations) } : {},
+		...extra?.images !== void 0 && extra.images.length > 0 ? { localImages: /* @__PURE__ */ new Map() } : {}
 	};
 }
-/**
-* Render the design brief — the ONLY channel into the tutor's context
-* (dsh models see tool results through output.render alone). Carries the
-* upstream design rules: study/practice/attached classification, the
-* 3000-8000 chars lesson pacing, sub-1000 merging, attached absorption, and
-* the strict JSON contract study_apply_design expects.
+/** Rewrite ![alt](relRef) refs in one file's content to the inlined data URLs
+*  (refs resolve relative to the markdown file's own directory). */
+function inlineLocalImages(content, filePath, images) {
+	if (images.size === 0) return content;
+	const dir = filePath.includes("/") ? filePath.slice(0, filePath.lastIndexOf("/")) : "";
+	const resolve = (ref) => {
+		const parts = `${dir}/${ref.replace(/^\.\//, "")}`.split("/");
+		const stack = [];
+		for (const p of parts) if (p === "..") stack.pop();
+		else if (p !== "." && p !== "") stack.push(p);
+		return stack.join("/");
+	};
+	return content.replace(/(!\[[^\]]*\]\()([^)\s]+)(\))/g, (m, open, ref, close) => {
+		if (/^(https?:|data:)/i.test(ref)) return m;
+		const data = images.get(resolve(ref));
+		return data === void 0 ? m : `${open}${data}${close}`;
+	});
+}
+/** translations/{lang}/{originalPath} → Map<originalPath, {lang, content}> (upstream translation pairing). */
+function collectTranslations(translations) {
+	const out = /* @__PURE__ */ new Map();
+	for (const t of translations) {
+		const m = t.path.match(/^translations\/([^/]+)\/(.+)$/);
+		if (m === null) continue;
+		out.set(m[2], {
+			lang: m[1],
+			content: t.content
+		});
+	}
+	return out;
+}
+/** Rewrite relative image refs to jsDelivr raw URLs (GitHub imports keep
+*  referencing the CDN — no download, upstream image-refs semantics). */
+function rewriteGithubImageRefs(content, filePath, owner, repo, branch) {
+	const dir = filePath.includes("/") ? filePath.slice(0, filePath.lastIndexOf("/")) : "";
+	const resolve = (ref) => {
+		const parts = `${dir}/${ref.replace(/^\.\//, "")}`.split("/");
+		const stack = [];
+		for (const p of parts) if (p === "..") stack.pop();
+		else if (p !== "." && p !== "") stack.push(p);
+		return stack.join("/");
+	};
+	return content.replace(/(!\[[^\]]*\]\()([^)\s]+)(\))/g, (m, open, ref, close) => {
+		if (/^(https?:|data:)/i.test(ref)) return m;
+		return `${open}https://cdn.jsdelivr.net/gh/${owner}/${repo}@${branch}/${resolve(ref)}${close}`;
+	});
+}
+/**
+* Build the pending design from URL-sourced docs (arXiv PDF text / web article
+* markdown, already chunked by prepareSingleDoc) — bodies ride along so apply
+* is fully offline, same as folder imports.
+* @param url - the normalized source URL (becomes sourceRef).
+* @param title - the fetched title (article title / arXiv id label).
+* @param docs - virtual docs ({stem}-01.md parts or one whole file).
+* @returns the pending design.
+*/
+function buildPendingDesignFromUrl(url, title, docs) {
+	const files = docs.map((doc) => ({
+		path: doc.path,
+		role: "original",
+		outline: extractOutlineWithCharCounts(doc.content, doc.path)
+	}));
+	const localContents = new Map(docs.map((doc) => [doc.path, doc.content]));
+	return {
+		source: "url",
+		url,
+		owner: "",
+		repo: title,
+		branch: "web",
+		courseTitle: title,
+		readmeExcerpt: docs[0]?.content.slice(0, 4e3) ?? "",
+		files,
+		fullTreeCount: docs.length,
+		localContents
+	};
+}
+/**
+* Render the design brief — the ONLY channel into the tutor's context
+* (dsh models see tool results through output.render alone). Carries the
+* upstream design rules: study/practice/attached classification, the
+* 3000-8000 chars lesson pacing, sub-1000 merging, attached absorption, and
+* the strict JSON contract study_apply_design expects.
 * @param pending - the pending design to present.
 * @returns the full brief text.
 */
-function renderDesignBrief(pending) {
+function renderDesignBrief(pending, part = 1) {
+	const parts = planBriefParts(pending.files);
+	const shown = parts[Math.min(Math.max(part, 1), parts.length) - 1];
 	const lines = [];
 	lines.push(`## Course design brief: ${pending.courseTitle}`);
-	lines.push(pending.source === "folder" ? `Folder import (${pending.fullTreeCount} files; ${pending.files.length} course files below).` : `Repo ${pending.owner}/${pending.repo}@${pending.branch} (${pending.fullTreeCount} paths in tree; ${pending.files.length} course files below).`);
+	lines.push(pending.source === "folder" ? `Folder import (${pending.fullTreeCount} files; ${shown.length} of ${pending.files.length} course files below).` : pending.source === "url" ? `Web import from ${pending.url} (${pending.fullTreeCount} document parts; ${shown.length} of ${pending.files.length} course files below).` : `Repo ${pending.owner}/${pending.repo}@${pending.branch} (${pending.fullTreeCount} paths in tree; ${shown.length} of ${pending.files.length} course files below).`);
+	if (parts.length > 1) {
+		lines.push("");
+		lines.push(`**Brief part ${Math.min(Math.max(part, 1), parts.length)} of ${parts.length}** (context-budget split, ~${Math.round(BRIEF_PART_TOKEN_BUDGET / 1e3)}k tokens per part). Design lessons ONLY from the files in this part, apply, then call the same import tool again with \`part\` = ${Math.min(Math.max(part, 1), parts.length) + 1 <= parts.length ? Math.min(Math.max(part, 1), parts.length) + 1 : "done"} — each part imports as its own course. File paths from other parts are valid but invisible to you; do not guess them.`);
+	}
 	lines.push("");
 	lines.push("### Repository README (first 4000 chars)");
 	lines.push(pending.readmeExcerpt.trim() === "" ? "(empty)" : pending.readmeExcerpt);
 	lines.push("");
 	lines.push("### Files (role hint · h1 · totalChars · H2/H3 outline with per-heading chars)");
-	for (const file of pending.files) {
+	for (const file of shown) {
 		lines.push(`- ${file.path} (role hint: ${file.role}, total ${file.outline.totalChars} chars, h1: ${file.outline.h1})`);
 		const headings = file.outline.headings.slice(0, 40);
 		for (const heading of headings) lines.push(`  ${"#".repeat(heading.level)} ${heading.title} [${heading.chars}]`);
@@ -2491,13 +3583,41 @@ function renderDesignBrief(pending) {
 	lines.push("Other rules:");
 	lines.push("- role hints are references, not verdicts — README tables usually mark real roles (Lesson link = study, Notebook/Lab = practice).");
 	lines.push("- if the directory layout is already clear (e.g. lessons/N-Topic/), keep its sections; do not over-reorganize.");
-	lines.push(`- anchor is the full heading text used to slice the body; omit it for whole-file lessons.${pending.files.length > 80 ? " This repo is large: design at file granularity (omit anchors, one lesson per file) to keep the JSON manageable." : ""}`);
+	lines.push(`- anchor is the full heading text used to slice the body; omit it for whole-file lessons.${shown.length > 80 ? " This part is large: design at file granularity (omit anchors, one lesson per file) to keep the JSON manageable." : ""}`);
 	lines.push("");
 	lines.push("Now design the course and call study_apply_design with:");
 	lines.push("{ \"sections\": [ { \"title\": \"...\", \"lessons\": [ { \"title\": \"...\", \"file\": \"<exact path from this brief>\", \"anchor\": \"<optional full heading text>\", \"world\": \"study\" | \"practice\" } ] } ] }");
 	lines.push("Use ONLY file paths that appear in this brief — anything else is dropped. Apply directly, then walk the learner through the course map.");
 	return lines.join("\n");
 }
+/** Context-budget per brief part (upstream import v2 batching semantics, dsh-adapted:
+*  the brief is the plugin's classification input, so the split rides the brief). */
+const BRIEF_PART_TOKEN_BUDGET = 48e3;
+/** Greedily pack brief files into token-budgeted parts (upstream Step-2 batching).
+*  A single file larger than the budget gets its own part (never dropped). */
+function planBriefParts(files, budgetTokens = BRIEF_PART_TOKEN_BUDGET) {
+	const parts = [];
+	let current = [];
+	let used = 0;
+	for (const file of files) {
+		const cost = estimateTokens(briefFileBlock(file));
+		if (current.length > 0 && used + cost > budgetTokens) {
+			parts.push(current);
+			current = [];
+			used = 0;
+		}
+		current.push(file);
+		used += cost;
+	}
+	if (current.length > 0) parts.push(current);
+	return parts.length > 0 ? parts : [[]];
+}
+/** The rendered brief block for one file (the unit the token budget packs). */
+function briefFileBlock(file) {
+	const lines = [`${file.path} (role hint: ${file.role}, total ${file.outline.totalChars} chars, h1: ${file.outline.h1})`];
+	for (const heading of file.outline.headings.slice(0, 40)) lines.push(`${"#".repeat(heading.level)} ${heading.title} [${heading.chars}]`);
+	return lines.join("\n");
+}
 /**
 * Extract H2/H3 headings with line numbers; headings inside ``` / ~~~ fences
 * are body text (upstream import-pipeline.ts extractHeadings).
@@ -2631,7 +3751,7 @@ function slugAnchor(title) {
 * @param contents - fetched body text per designed file (missing key = loud failure).
 * @returns the parsed course ready for importCourse.
 */
-function buildCourseFromDesign(courseTitle, validated, contents) {
+function buildCourseFromDesign(courseTitle, validated, contents, translations) {
 	const headingsCache = /* @__PURE__ */ new Map();
 	const headingsOf = (file) => {
 		const cached = headingsCache.get(file);
@@ -2653,12 +3773,23 @@ function buildCourseFromDesign(courseTitle, validated, contents) {
 				const titleIndex = lesson.anchor === null ? -1 : findTitleIndex(headings, lesson.anchor);
 				const isFirst = !firstLessonSeen.has(lesson.file);
 				firstLessonSeen.add(lesson.file);
+				const pair = translations?.get(lesson.file);
+				let translation;
+				if (pair !== void 0) {
+					const tHeadings = extractHeadings(pair.content);
+					const tIndex = lesson.anchor === null ? -1 : findTitleIndex(tHeadings, lesson.anchor);
+					translation = sliceLessonBody(pair.content, tHeadings, tIndex, isFirst);
+				}
 				return {
 					title: lesson.title,
 					anchor: slugAnchor(lesson.title),
 					body: sliceLessonBody(content, headings, titleIndex, isFirst),
 					sourceFilePath: lesson.file,
-					world: lesson.world
+					world: lesson.world,
+					...translation !== void 0 ? {
+						translation,
+						translationLang: pair.lang
+					} : {}
 				};
 			});
 			return {
@@ -2713,14 +3844,14 @@ function designBriefLines(value) {
 * @returns card lines.
 */
 function mapLines(value) {
-	const lines = [`🗺 ${value.title} — ${value.counts.mastered}/${value.counts.total} mastered`];
+	const lines = [`🗺 ${value.title} [courseId ${value.courseId}] — ${value.counts.mastered}/${value.counts.total} mastered`];
 	for (const section of value.tree) {
 		lines.push(`▍${section.title}`);
 		for (const lesson of section.lessons) {
 			const mastery = lesson.masteryPct === null ? "" : ` · ${lesson.masteryPct}%${lesson.crown >= 4 ? " 👑" : ""}`;
 			const weak = lesson.weakConcepts > 0 ? ` · ⚡${lesson.weakConcepts}` : "";
 			const friction = lesson.frictionCount > 0 ? ` · 😣${lesson.frictionCount}` : "";
-			lines.push(`  ${statusGlyph(lesson.kind, lesson.status)} ${lesson.title}${mastery}${weak}${friction}`);
+			lines.push(`  ${statusGlyph(lesson.kind, lesson.status)} ${lesson.title} [lessonId ${lesson.id}]${mastery}${weak}${friction}`);
 		}
 	}
 	return lines;
@@ -2745,7 +3876,7 @@ function dueLines(value) {
 	const lines = [`🔁 ${value.total} due`];
 	for (const item of value.due) {
 		const overdue = item.overdueDays > 0 ? ` · ${item.overdueDays}d overdue` : "";
-		lines.push(`  ⏰ ${item.lessonTitle} — ${item.courseTitle}${overdue}`);
+		lines.push(`  ⏰ ${item.lessonTitle} [lessonId ${item.lessonId}] — ${item.courseTitle}${overdue}`);
 	}
 	return lines;
 }
@@ -2876,9 +4007,37 @@ function toMapValue(course) {
 	};
 }
 /** Canonical value of `study_lesson`. */
+/** The learner-state block (upstream learner-model buildLearnerSnapshot): one
+*  composed projection of mastery/status/weak concepts/friction/memory that the
+*  tutor consumes whole instead of re-deriving from scattered fields. */
+function learnerStateLine(ref, state) {
+	const l = ref.lesson;
+	const parts = [];
+	parts.push(`status ${l.status}, mastery ${l.mastery === null ? "untracked" : `${Math.round(l.mastery * 100)}%`}, strategy ${strategyBand(l.mastery)}`);
+	const weak = (l.concepts ?? []).filter((_c, i) => (l.conceptMastery?.[i] ?? .5) < .7);
+	if (weak.length > 0) parts.push(`weak concepts: ${weak.map((c) => c.title).join("、")}`);
+	const frictionCats = [...new Set(l.friction.slice(-5).map((f) => f.category))];
+	if (frictionCats.length > 0) parts.push(`recent friction: ${frictionCats.join("/")}`);
+	if (l.memory !== null) parts.push(`lesson memory: ${l.memory}`);
+	if (state.memoryGlobal !== null) parts.push(`global memory: ${state.memoryGlobal}`);
+	return parts.join(" | ");
+}
 function toLessonValue(ref, state) {
 	const next = nextLesson(ref.course, ref.lesson.id);
 	const pending = state.proposals.find((p) => p.lessonId === ref.lesson.id && p.status === "pending");
+	/** Exam design guide (upstream exam-logic): question quota from the section's
+	*  KC union, per-question time rule, star thresholds — only on exam nodes. */
+	const examGuide = ref.lesson.kind === "exam" ? (() => {
+		const kcTitles = [...new Set(ref.section.lessons.filter((l) => l.kind !== "exam" && l.concepts !== null).flatMap((l) => l.concepts.map((c) => c.title)))];
+		return {
+			questionCount: planExamQuota(kcTitles).reduce((a, b) => a + b, 0),
+			kcCount: kcTitles.length,
+			timeLimitRule: "per-question seconds = 45 + cjkChars/5 + words/3 + options×8, +25 code block, +25 formula, clamp 60–300 (questionTimeLimitSec)",
+			starsRule: "≥95%→3★, ≥80%→2★, ≥60%→1★, below→0 (best-of kept; report with study_exam_result)",
+			bestStars: ref.lesson.examStars ?? 0,
+			examAttempts: ref.lesson.examAttempts ?? 0
+		};
+	})() : null;
 	return {
 		lessonId: ref.lesson.id,
 		courseId: ref.course.id,
@@ -2905,7 +4064,10 @@ function toLessonValue(ref, state) {
 			id: pending.id,
 			rationale: pending.rationale
 		},
-		nextLessonId: next?.id ?? null
+		nextLessonId: next?.id ?? null,
+		learnerState: learnerStateLine(ref, state),
+		...ref.lesson.summary !== void 0 ? { summary: ref.lesson.summary } : {},
+		...examGuide !== null ? { examGuide } : {}
 	};
 }
 /**
@@ -2948,6 +4110,8 @@ function studyTools(store, deps = {}) {
 	* replaces an unconsumed one.
 	*/
 	let pendingDesign = null;
+	/** Which context-budget part of the pending brief the tutor last asked for. */
+	let pendingPart = 1;
 	/** Run a mutating state operation and persist. */
 	const mutate = (fn) => {
 		const result = fn(store.get());
@@ -3088,13 +4252,21 @@ function studyTools(store, deps = {}) {
 			fullTreeCount: {
 				type: "integer",
 				required: true
+			},
+			part: {
+				type: "integer",
+				description: "Brief part this call rendered (context-budget batching)."
+			},
+			partCount: {
+				type: "integer",
+				description: "Total brief parts; >1 means design+apply per part."
 			}
 		}
 	}] } };
 	/** Shared render: the brief rides the design_required branch; imported stays the old summary. */
 	const designOrImportedRender = (_args, value) => [{
 		type: "text",
-		text: value.status === "design_required" ? pendingDesign === null ? "Course design required — the brief is no longer pending; call the import tool again to re-fetch it." : renderDesignBrief(pendingDesign) : `Imported course “${value.title}” (${value.sections} sections, ${value.lessons} lessons). First lesson: “${value.firstLessonTitle}” (id ${value.firstLessonId}).`
+		text: value.status === "design_required" ? pendingDesign === null ? "Course design required — the brief is no longer pending; call the import tool again to re-fetch it." : renderDesignBrief(pendingDesign, pendingPart) : `Imported course “${value.title}” (${value.sections} sections, ${value.lessons} lessons). First lesson: “${value.firstLessonTitle}” (id ${value.firstLessonId}).`
 	}];
 	const designOrImportedPresent = {
 		presentationMeta: (_args, value) => value.status === "design_required" ? designBriefLines(value) : importLines(value),
@@ -3103,351 +4275,378 @@ function studyTools(store, deps = {}) {
 			content: textBlocks(result.meta)
 		})
 	};
-	return [
-		importMarkdown,
-		defineTool({
-			name: "study_import_folder",
-			description: "Start importing a local folder: scans markdown, txt, html, Jupyter notebooks, rst/Rmd/org/adoc, and 30+ code file types (PDF/PPTX unsupported), then returns a design brief — the TUTOR designs the course structure from it and applies the result with study_apply_design (fully offline). Re-importing an already-imported path returns the existing course directly.",
-			parameters: {
-				path: {
-					type: "string",
-					required: true,
-					description: "Absolute path of the folder to scan."
-				},
-				title: {
-					type: "string",
-					description: "Optional course title overriding the folder name / README H1."
-				}
-			},
-			output: {
-				...designOrImportedOutput,
-				render: designOrImportedRender
+	const importFolder = defineTool({
+		name: "study_import_folder",
+		description: "Start importing a local folder: scans markdown, txt, html, Jupyter notebooks, rst/Rmd/org/adoc, and 30+ code file types (PDF/PPTX unsupported), then returns a design brief — the TUTOR designs the course structure from it and applies the result with study_apply_design (fully offline). Re-importing an already-imported path returns the existing course directly.",
+		parameters: {
+			path: {
+				type: "string",
+				required: true,
+				description: "Absolute path of the folder to scan."
 			},
-			async execute(args) {
-				if (!existsSync(args.path)) throw new Error(`lookatstudy-plugin: folder does not exist: ${args.path}`);
-				const existing = store.get().courses.find((c) => c.source === "folder" && c.sourceRef === args.path);
-				if (existing !== void 0) return {
-					status: "imported",
-					...toImportValue(existing)
-				};
-				const docs = await scanFolder(args.path);
-				if (docs.length === 0) throw new Error(`lookatstudy-plugin: no importable files found in ${args.path}`);
-				const title = args.title ?? basename(args.path.replaceAll("\\", "/"));
-				pendingDesign = buildPendingDesignFromFolder(args.path, title, docs);
-				return {
-					status: "design_required",
-					repo: pendingDesign.repo,
-					branch: pendingDesign.branch,
-					courseTitle: pendingDesign.courseTitle,
-					fileCount: pendingDesign.files.length,
-					fullTreeCount: pendingDesign.fullTreeCount
-				};
+			title: {
+				type: "string",
+				description: "Optional course title overriding the folder name / README H1."
 			},
-			timeoutMs: 6e4,
-			presentCall: (args) => ({
-				card: "generic",
-				title: `Scan folder: ${args.path}`,
-				kind: "read",
-				rawInput: args.path
-			}),
-			...designOrImportedPresent
+			part: {
+				type: "integer",
+				description: "Which context-budget brief part to render (1-based); relevant only when the folder is huge."
+			}
+		},
+		output: {
+			...designOrImportedOutput,
+			render: designOrImportedRender
+		},
+		async execute(args) {
+			if (!existsSync(args.path)) throw new Error(`lookatstudy-plugin: folder does not exist: ${args.path}`);
+			const part = args.part ?? 1;
+			const existing = part <= 1 ? store.get().courses.find((c) => c.source === "folder" && c.sourceRef === args.path) : void 0;
+			if (existing !== void 0) return {
+				status: "imported",
+				...toImportValue(existing)
+			};
+			const inventory = await buildLocalInventory(args.path);
+			const docs = inventory.docs;
+			if (docs.length === 0) throw new Error(`lookatstudy-plugin: no importable files found in ${args.path}`);
+			const title = args.title ?? basename(args.path.replaceAll("\\", "/"));
+			pendingDesign = buildPendingDesignFromFolder(args.path, title, docs, {
+				translations: inventory.translations,
+				images: inventory.images
+			});
+			const localImages = /* @__PURE__ */ new Map();
+			for (const img of inventory.images) {
+				if (img.absPath === "" || img.source === "pdf_page") continue;
+				try {
+					const buf = await readFile(img.absPath);
+					if (buf.length > 2e5) continue;
+					localImages.set(img.path, `data:${img.mime};base64,${buf.toString("base64")}`);
+				} catch {}
+			}
+			if (localImages.size > 0) pendingDesign.localImages = localImages;
+			pendingPart = part;
+			return designRequiredValue(pendingDesign, part);
+		},
+		timeoutMs: 6e4,
+		presentCall: (args) => ({
+			card: "generic",
+			title: `Scan folder: ${args.path}`,
+			kind: "read",
+			rawInput: args.path
 		}),
-		defineTool({
-			name: "study_import_github",
-			description: "Start importing a GitHub learning repository: fetches the README outline and every course file's heading outline (with char counts) through the jsDelivr CDN, then returns a design brief — the TUTOR designs the course structure (sections/lessons/anchors/worlds) from it and applies the result with study_apply_design. Re-importing an already-imported URL returns the existing course directly. Awesome-lists are rejected.",
-			parameters: {
-				url: {
-					type: "string",
-					required: true,
-					description: "Repository URL, e.g. https://github.com/microsoft/AI-For-Beginners."
-				},
-				branch: {
-					type: "string",
-					description: "Branch to read (main tried, then master); defaults to main."
-				}
+		...designOrImportedPresent
+	});
+	/** Stamp the requested brief part onto the pending design and build the design_required value. */
+	const designRequiredValue = (pd, part) => {
+		const partCount = planBriefParts(pd.files).length;
+		pd.part = part;
+		pd.partCount = partCount;
+		return {
+			status: "design_required",
+			repo: pd.repo,
+			branch: pd.branch,
+			courseTitle: partCount > 1 ? `${pd.courseTitle} (part ${part})` : pd.courseTitle,
+			fileCount: planBriefParts(pd.files)[Math.min(part, partCount) - 1].length,
+			fullTreeCount: pd.fullTreeCount,
+			...partCount > 1 ? {
+				part,
+				partCount
+			} : {}
+		};
+	};
+	/** Shared GitHub import flow — study_import_github's core, reused verbatim by
+	*  study_import_url's github branch (routing is the only difference). */
+	const runGithubImport = async (url, branch, exec, part = 1) => {
+		const { owner, repo } = parseGithubUrl(url);
+		const resolvedBranch = branch ?? "main";
+		const fetchFn = signalFetch(exec.signal, baseFetch);
+		const existing = part <= 1 ? store.get().courses.find((c) => c.source === "github" && c.sourceRef === url) : void 0;
+		if (existing !== void 0) return {
+			status: "imported",
+			...toImportValue(existing)
+		};
+		const inventory = await fetchRepoInventory(owner, repo, resolvedBranch, fetchFn, void 0, exec.signal);
+		pendingDesign = buildPendingDesign(url, owner, repo, inventory, await fetchFileOutlines(inventory.fileList.map((f) => f.path), owner, repo, inventory.branch, fetchFn, void 0, exec.signal));
+		if (pendingDesign.files.length === 0) throw new Error("lookatstudy-plugin: course files were discovered but no outlines could be fetched (CDN unreachable?)");
+		pendingPart = part;
+		return designRequiredValue(pendingDesign, part);
+	};
+	const importGithub = defineTool({
+		name: "study_import_github",
+		description: "Start importing a GitHub learning repository: fetches the README outline and every course file's heading outline (with char counts) through the jsDelivr CDN, then returns a design brief — the TUTOR designs the course structure (sections/lessons/anchors/worlds) from it and applies the result with study_apply_design. Re-importing an already-imported URL returns the existing course directly. Awesome-lists are rejected.",
+		parameters: {
+			url: {
+				type: "string",
+				required: true,
+				description: "Repository URL, e.g. https://github.com/microsoft/AI-For-Beginners."
 			},
-			output: {
-				...designOrImportedOutput,
-				render: designOrImportedRender
+			branch: {
+				type: "string",
+				description: "Branch to read (main tried, then master); defaults to main."
 			},
-			async execute(args, exec) {
-				const { owner, repo } = parseGithubUrl(args.url);
-				const branch = args.branch ?? "main";
-				const fetchFn = signalFetch(exec.signal, baseFetch);
-				const existing = store.get().courses.find((c) => c.source === "github" && c.sourceRef === args.url);
+			part: {
+				type: "integer",
+				description: "Which context-budget brief part to render (1-based); relevant only for huge repos."
+			}
+		},
+		output: {
+			...designOrImportedOutput,
+			render: designOrImportedRender
+		},
+		execute: (args, exec) => runGithubImport(args.url, args.branch, exec, args.part ?? 1),
+		timeoutMs: 18e4,
+		presentCall: (args) => ({
+			card: "generic",
+			title: `Import GitHub course: ${args.url}`,
+			kind: "fetch"
+		}),
+		...designOrImportedPresent
+	});
+	const importUrl = defineTool({
+		name: "study_import_url",
+		description: "Import any learning URL by auto-routing: GitHub repos reuse the repository import; arXiv papers download the PDF and extract its text layer; other http(s) pages get web-article extraction (nav/ads stripped, honest failure on non-article pages). All routes return the same design brief the tutor designs against (apply with study_apply_design). Video links (B站/YouTube/抖音) are classified with title metadata but cannot be transcribed here — ask the learner to paste the transcript/subtitles and use study_import_markdown instead.",
+		parameters: {
+			url: {
+				type: "string",
+				required: true,
+				description: "The URL to import: github.com repo, arxiv.org paper, or any web article page."
+			},
+			part: {
+				type: "integer",
+				description: "Which context-budget brief part to render (1-based); relevant only for enormous documents."
+			}
+		},
+		output: {
+			...designOrImportedOutput,
+			render: designOrImportedRender
+		},
+		async execute(args, exec) {
+			const route = routeImportUrl(args.url);
+			if (route === null) throw new Error(`lookatstudy-plugin: ${JSON.stringify(args.url)} is not a recognizable import URL (github repo / arxiv paper / web article / video link)`);
+			if (route.kind === "github") return runGithubImport(args.url, void 0, exec, args.part ?? 1);
+			const fetchFn = signalFetch(exec.signal, baseFetch);
+			if (route.kind === "video") {
+				if (route.source === "bilibili") {
+					const meta = await fetchBilibiliMeta(route.url, fetchFn, exec.signal);
+					const parts = meta.parts.length > 0 ? `, ${meta.parts.length} 分P` : "";
+					throw new Error(`lookatstudy-plugin: B站视频《${meta.title}》(UP:${meta.owner}${parts})已识别,但插件内无字幕拉取与音频转写能力。请让学习者把字幕/文稿粘贴进来,用 study_import_markdown 导入。`);
+				}
+				throw new Error(`lookatstudy-plugin: ${route.url} 是视频链接(YouTube/抖音需要 yt-dlp,插件环境不可用)。请让学习者把字幕/文稿粘贴进来,用 study_import_markdown 导入。`);
+			}
+			if (route.flavor === "arxiv") {
+				const text = parsePdfText(await downloadToBuffer(route.pdfUrl, fetchFn, { signal: exec.signal }));
+				if (!text || text.replace(/\s+/g, "").length < 200) throw new Error("lookatstudy-plugin: arXiv PDF has no extractable text layer (scanned/image PDF) — try the HTML version or paste the abstract as markdown");
+				const docs = prepareSingleDoc(`arxiv-${route.arxivId}`, `# arXiv:${route.arxivId}\n\n${text}`);
+				if (docs.length === 0) throw new Error("lookatstudy-plugin: arXiv PDF text was empty after chunking");
+				const part = args.part ?? 1;
+				const existing = part <= 1 ? store.get().courses.find((c) => c.source === "url" && c.sourceRef === route.url) : void 0;
 				if (existing !== void 0) return {
 					status: "imported",
 					...toImportValue(existing)
 				};
-				const inventory = await fetchRepoInventory(owner, repo, branch, fetchFn, void 0, exec.signal);
-				const outlines = await fetchFileOutlines(inventory.fileList.map((f) => f.path), owner, repo, inventory.branch, fetchFn, void 0, exec.signal);
-				pendingDesign = buildPendingDesign(args.url, owner, repo, inventory, outlines);
-				if (pendingDesign.files.length === 0) throw new Error("lookatstudy-plugin: course files were discovered but no outlines could be fetched (CDN unreachable?)");
-				return {
-					status: "design_required",
-					repo: `${owner}/${repo}`,
-					branch: pendingDesign.branch,
-					courseTitle: pendingDesign.courseTitle,
-					fileCount: pendingDesign.files.length,
-					fullTreeCount: pendingDesign.fullTreeCount
-				};
-			},
-			timeoutMs: 18e4,
-			presentCall: (args) => ({
-				card: "generic",
-				title: `Import GitHub course: ${args.url}`,
-				kind: "fetch"
-			}),
-			...designOrImportedPresent
+				pendingDesign = buildPendingDesignFromUrl(route.url, `arXiv:${route.arxivId}`, docs);
+				pendingPart = part;
+				return designRequiredValue(pendingDesign, part);
+			}
+			const part = args.part ?? 1;
+			const identity = normalizeUrlIdentity(route.url);
+			const existing = part <= 1 ? store.get().courses.find((c) => c.source === "url" && c.sourceRef === identity) : void 0;
+			if (existing !== void 0) return {
+				status: "imported",
+				...toImportValue(existing)
+			};
+			const resp = await fetchFn(route.url, { headers: { "User-Agent": "Mozilla/5.0 (compatible; LookatStudyPlugin/0.9)" } });
+			if (!resp.ok) throw new Error(`lookatstudy-plugin: page fetch failed (HTTP ${resp.status}): ${route.url}`);
+			const html = await resp.text();
+			const article = extractArticle(html, route.url);
+			if (article === null) throw new Error(`lookatstudy-plugin: ${route.url} does not look like an article page (no readable body found) — login walls, indexes and app shells are rejected honestly rather than imported as noise`);
+			const docs = prepareSingleDoc(article.title.slice(0, 60), article.markdown);
+			if (docs.length === 0) throw new Error("lookatstudy-plugin: article body was empty after chunking");
+			pendingDesign = buildPendingDesignFromUrl(identity, article.title, docs);
+			pendingPart = part;
+			return designRequiredValue(pendingDesign, part);
+		},
+		timeoutMs: 12e4,
+		presentCall: (args) => ({
+			card: "generic",
+			title: `Import URL: ${args.url}`,
+			kind: "fetch"
 		}),
-		defineTool({
-			name: "study_apply_design",
-			description: "Apply the tutor-designed course structure to the pending import (the one study_import_github or study_import_folder returned design_required for). Every lesson's file must come from the design brief — unknown paths are dropped (anti-hallucination); lesson bodies are sliced by their anchor heading and the course is imported. On a validation or fetch error the tutor fixes the design and simply calls again.",
-			parameters: { sections: {
-				type: "array",
-				required: true,
-				description: "Designed sections in learning order.",
-				items: {
-					type: "object",
-					additionalProperties: false,
-					properties: {
-						title: {
-							type: "string",
-							required: true,
-							description: "Section title (in the learner's language)."
-						},
-						lessons: {
-							type: "array",
-							required: true,
-							items: {
-								type: "object",
-								additionalProperties: false,
-								properties: {
-									title: {
-										type: "string",
-										required: true,
-										description: "Lesson title."
-									},
-									file: {
-										type: "string",
-										required: true,
-										description: "Exact file path from the design brief."
-									},
-									anchor: {
-										type: "string",
-										description: "Full H2/H3 heading text the lesson body starts at; omit for whole-file lessons."
-									},
-									world: {
-										type: "string",
-										description: "\"study\" (explanation) or \"practice\" (exercise/lab/notebook); anything else is treated as study."
-									}
+		...designOrImportedPresent
+	});
+	const applyDesign = defineTool({
+		name: "study_apply_design",
+		description: "Apply the tutor-designed course structure to the pending import (the one study_import_github or study_import_folder returned design_required for). Every lesson's file must come from the design brief — unknown paths are dropped (anti-hallucination); lesson bodies are sliced by their anchor heading and the course is imported. On a validation or fetch error the tutor fixes the design and simply calls again.",
+		parameters: { sections: {
+			type: "array",
+			required: true,
+			description: "Designed sections in learning order.",
+			items: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					title: {
+						type: "string",
+						required: true,
+						description: "Section title (in the learner's language)."
+					},
+					lessons: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								title: {
+									type: "string",
+									required: true,
+									description: "Lesson title."
+								},
+								file: {
+									type: "string",
+									required: true,
+									description: "Exact file path from the design brief."
+								},
+								anchor: {
+									type: "string",
+									description: "Full H2/H3 heading text the lesson body starts at; omit for whole-file lessons."
+								},
+								world: {
+									type: "string",
+									description: "\"study\" (explanation) or \"practice\" (exercise/lab/notebook); anything else is treated as study."
 								}
 							}
 						}
 					}
 				}
-			} },
-			output: {
-				schema: {
-					type: "object",
-					additionalProperties: false,
-					properties: {
-						courseId: {
-							type: "string",
-							required: true
-						},
-						title: {
-							type: "string",
-							required: true
-						},
-						sections: {
-							type: "integer",
-							required: true
-						},
-						lessons: {
-							type: "integer",
-							required: true
-						},
-						firstLessonId: {
-							type: "string",
-							required: true
-						},
-						firstLessonTitle: {
-							type: "string",
-							required: true
-						},
-						droppedLessons: {
-							type: "integer",
-							required: true
-						}
-					}
-				},
-				render: (_args, value) => [{
-					type: "text",
-					text: `Imported designed course “${value.title}” (${value.sections} sections, ${value.lessons} lessons${value.droppedLessons > 0 ? `, ${value.droppedLessons} hallucinated lesson(s) dropped` : ""}). First lesson: “${value.firstLessonTitle}” (id ${value.firstLessonId}). Present the course map to the learner.`
-				}]
-			},
-			async execute(args, exec) {
-				const pd = pendingDesign;
-				if (pd === null) throw new Error("lookatstudy-plugin: no pending course design — call study_import_github or study_import_folder first (a dsh restart also clears it)");
-				const validated = validateDesign(args, new Set(pd.files.map((f) => f.path)));
-				const uniqueFiles = [...new Set(validated.sections.flatMap((s) => s.lessons.map((l) => l.file)))];
-				const contents = /* @__PURE__ */ new Map();
-				if (pd.localContents !== void 0) for (const file of uniqueFiles) {
-					const text = pd.localContents.get(file);
-					if (text === void 0) throw new Error(`lookatstudy-plugin: designed file ${JSON.stringify(file)} is not in the scanned folder — use only paths from the design brief`);
-					contents.set(file, text);
-				}
-				else {
-					const failed = [];
-					const fetchFn = signalFetch(exec.signal, baseFetch);
-					for (let i = 0; i < uniqueFiles.length; i += 5) {
-						if (exec.signal.aborted) throw new Error("lookatstudy-plugin: import aborted");
-						const batch = uniqueFiles.slice(i, i + 5);
-						const texts = await Promise.all(batch.map((f) => fetchSingleFileContent(f, pd.owner, pd.repo, pd.branch, fetchFn)));
-						for (let j = 0; j < batch.length; j++) if (texts[j] === null) failed.push(batch[j]);
-						else contents.set(batch[j], texts[j]);
+			}
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					courseId: {
+						type: "string",
+						required: true
+					},
+					title: {
+						type: "string",
+						required: true
+					},
+					sections: {
+						type: "integer",
+						required: true
+					},
+					lessons: {
+						type: "integer",
+						required: true
+					},
+					firstLessonId: {
+						type: "string",
+						required: true
+					},
+					firstLessonTitle: {
+						type: "string",
+						required: true
+					},
+					droppedLessons: {
+						type: "integer",
+						required: true
 					}
-					if (contents.size === 0) throw new Error(`lookatstudy-plugin: every designed file failed to fetch (${failed.length}) — the CDN path is unreachable; retry or re-import`);
-					if (failed.length > 0) throw new Error(`lookatstudy-plugin: ${failed.length} designed file(s) failed to fetch: ${failed.join(", ")} — drop or fix them and call study_apply_design again`);
 				}
-				const parsed = buildCourseFromDesign(pd.courseTitle, validated, contents);
-				requireParsedLessons(parsed);
-				const value = mutate((state) => toImportValue(importCourse(state, parsed, pd.source, pd.url)));
-				pendingDesign = null;
-				return {
-					...value,
-					droppedLessons: validated.droppedLessons
-				};
 			},
-			timeoutMs: 18e4,
-			presentCall: () => ({
-				card: "generic",
-				title: "Apply course design",
-				kind: "edit"
-			}),
-			presentationMeta: (_args, value) => [...importLines(value), ...value.droppedLessons > 0 ? [`${value.droppedLessons} dropped (files outside the brief)`] : []],
-			presentResult: (_args, result) => ({
-				card: "generic",
-				content: textBlocks(result.meta)
-			})
+			render: (_args, value) => [{
+				type: "text",
+				text: `Imported designed course “${value.title}” (${value.sections} sections, ${value.lessons} lessons${value.droppedLessons > 0 ? `, ${value.droppedLessons} hallucinated lesson(s) dropped` : ""}). First lesson: “${value.firstLessonTitle}” (id ${value.firstLessonId}). Present the course map to the learner.`
+			}]
+		},
+		async execute(args, exec) {
+			const pd = pendingDesign;
+			if (pd === null) throw new Error("lookatstudy-plugin: no pending course design — call study_import_github or study_import_folder first (a dsh restart also clears it)");
+			const validated = validateDesign(args, new Set(pd.files.map((f) => f.path)));
+			const uniqueFiles = [...new Set(validated.sections.flatMap((s) => s.lessons.map((l) => l.file)))];
+			const contents = /* @__PURE__ */ new Map();
+			if (pd.localContents !== void 0) for (const file of uniqueFiles) {
+				const text = pd.localContents.get(file);
+				if (text === void 0) throw new Error(`lookatstudy-plugin: designed file ${JSON.stringify(file)} is not in the scanned folder — use only paths from the design brief`);
+				contents.set(file, pd.localImages === void 0 ? text : inlineLocalImages(text, file, pd.localImages));
+			}
+			else {
+				const failed = [];
+				const fetchFn = signalFetch(exec.signal, baseFetch);
+				for (let i = 0; i < uniqueFiles.length; i += 5) {
+					if (exec.signal.aborted) throw new Error("lookatstudy-plugin: import aborted");
+					const batch = uniqueFiles.slice(i, i + 5);
+					const texts = await Promise.all(batch.map((f) => fetchSingleFileContent(f, pd.owner, pd.repo, pd.branch, fetchFn)));
+					for (let j = 0; j < batch.length; j++) if (texts[j] === null) failed.push(batch[j]);
+					else contents.set(batch[j], rewriteGithubImageRefs(texts[j], batch[j], pd.owner, pd.repo, pd.branch));
+				}
+				if (contents.size === 0) throw new Error(`lookatstudy-plugin: every designed file failed to fetch (${failed.length}) — the CDN path is unreachable; retry or re-import`);
+				if (failed.length > 0) throw new Error(`lookatstudy-plugin: ${failed.length} designed file(s) failed to fetch: ${failed.join(", ")} — drop or fix them and call study_apply_design again`);
+			}
+			const parsed = buildCourseFromDesign(pd.part !== void 0 && pd.partCount !== void 0 && pd.partCount > 1 ? `${pd.courseTitle} (part ${pd.part})` : pd.courseTitle, validated, contents, pd.translations);
+			requireParsedLessons(parsed);
+			const value = mutate((state) => toImportValue(importCourse(state, parsed, pd.source, pd.url)));
+			pendingDesign = null;
+			pendingPart = 1;
+			return {
+				...value,
+				droppedLessons: validated.droppedLessons
+			};
+		},
+		timeoutMs: 18e4,
+		presentCall: () => ({
+			card: "generic",
+			title: "Apply course design",
+			kind: "edit"
 		}),
-		defineTool({
-			name: "study_courses",
-			description: "List imported courses with progress, average mastery, due reviews, and the current lesson id.",
-			parameters: {},
-			output: {
-				schema: {
-					type: "object",
-					additionalProperties: false,
-					properties: {
-						total: {
-							type: "integer",
-							required: true
-						},
-						courses: {
-							type: "array",
-							required: true,
-							items: {
-								type: "object",
-								additionalProperties: false,
-								properties: {
-									courseId: {
-										type: "string",
-										required: true
-									},
-									title: {
-										type: "string",
-										required: true
-									},
-									source: {
-										type: "string",
-										required: true,
-										enum: [
-											"markdown",
-											"folder",
-											"github"
-										]
-									},
-									total: {
-										type: "integer",
-										required: true
-									},
-									mastered: {
-										type: "integer",
-										required: true
-									},
-									avgMasteryPct: {
-										...nullableInteger,
-										required: true
-									},
-									dueCount: {
-										type: "integer",
-										required: true
-									},
-									currentLessonId: {
-										...nullableString,
-										required: true
-									}
-								}
-							}
-						}
-					}
-				},
-				render: (_args, value) => [{
-					type: "text",
-					text: value.courses.length === 0 ? "No courses imported yet. Import one with study_import_markdown, study_import_folder, or study_import_github." : value.courses.map((c) => `“${c.title}” (${c.source}) — ${c.mastered}/${c.total} lessons mastered${c.avgMasteryPct === null ? "" : `, avg mastery ${c.avgMasteryPct}%`}${c.dueCount === 0 ? "" : `, ${c.dueCount} reviews due`}${c.currentLessonId === null ? "" : `, current lesson ${c.currentLessonId}`}`).join("\n")
-				}]
-			},
-			async execute() {
-				const summaries = courseSummaries(store.get(), /* @__PURE__ */ new Date());
-				return {
-					total: summaries.length,
-					courses: summaries.map((s) => ({
-						courseId: s.courseId,
-						title: s.title,
-						source: s.source,
-						total: s.total,
-						mastered: s.mastered,
-						avgMasteryPct: s.avgMasteryPct,
-						dueCount: s.dueCount,
-						currentLessonId: s.currentLessonId
-					}))
-				};
-			},
-			isConcurrencySafe: () => true,
-			presentCall: () => ({
-				card: "generic",
-				title: "List courses",
-				kind: "read"
-			})
-		}),
-		defineTool({
-			name: "study_map",
-			description: "Show one course's skill tree: sections, lessons with locked/available/in_progress/mastered status, mastery, weak-concept count (⚡), and friction count — the weak spots to target.",
-			parameters: { courseId: {
-				type: "string",
-				required: true,
-				description: "Course id from an import result or study_courses."
-			} },
-			output: {
-				schema: {
-					type: "object",
-					additionalProperties: false,
-					properties: {
-						courseId: {
-							type: "string",
-							required: true
-						},
-						title: {
-							type: "string",
-							required: true
-						},
-						counts: {
+		presentationMeta: (_args, value) => [...importLines(value), ...value.droppedLessons > 0 ? [`${value.droppedLessons} dropped (files outside the brief)`] : []],
+		presentResult: (_args, result) => ({
+			card: "generic",
+			content: textBlocks(result.meta)
+		})
+	});
+	const listCourses = defineTool({
+		name: "study_courses",
+		description: "List imported courses with progress, average mastery, due reviews, and the current lesson id — plus the learner's XP/level/streak block (upstream xp-service + streak). With `query`, runs a full-text multi-keyword AND search over every lesson title AND body (upstream course-tree-filter extended) and returns the hits alongside the course list.",
+		parameters: { query: {
+			type: "string",
+			description: "Optional full-text search: space-separated keywords, all must hit title or body."
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					total: {
+						type: "integer",
+						required: true
+					},
+					courses: {
+						type: "array",
+						required: true,
+						items: {
 							type: "object",
-							required: true,
 							additionalProperties: false,
 							properties: {
+								courseId: {
+									type: "string",
+									required: true
+								},
+								title: {
+									type: "string",
+									required: true
+								},
+								source: {
+									type: "string",
+									required: true,
+									enum: [
+										"markdown",
+										"folder",
+										"github",
+										"url"
+									]
+								},
 								total: {
 									type: "integer",
 									required: true
@@ -3456,326 +4655,322 @@ function studyTools(store, deps = {}) {
 									type: "integer",
 									required: true
 								},
-								available: {
+								avgMasteryPct: {
+									...nullableInteger,
+									required: true
+								},
+								dueCount: {
 									type: "integer",
 									required: true
-								}
-							}
-						},
-						tree: {
-							type: "array",
-							required: true,
-							items: {
-								type: "object",
-								additionalProperties: false,
-								properties: {
-									title: {
-										type: "string",
-										required: true
-									},
-									lessons: {
-										type: "array",
-										required: true,
-										items: {
-											type: "object",
-											additionalProperties: false,
-											properties: {
-												id: {
-													type: "string",
-													required: true
-												},
-												title: {
-													type: "string",
-													required: true
-												},
-												kind: {
-													type: "string",
-													required: true,
-													enum: [...LESSON_KINDS]
-												},
-												status: {
-													type: "string",
-													required: true,
-													enum: [...LESSON_STATUSES]
-												},
-												masteryPct: {
-													...nullableInteger,
-													required: true
-												},
-												crown: {
-													type: "integer",
-													required: true
-												},
-												weakConcepts: {
-													type: "integer",
-													required: true
-												},
-												frictionCount: {
-													type: "integer",
-													required: true
-												}
-											}
-										}
-									}
+								},
+								currentLessonId: {
+									...nullableString,
+									required: true
 								}
 							}
 						}
-					}
-				},
-				render: (_args, value) => textBlocks(mapLines(value))
-			},
-			async execute(args) {
-				return toMapValue(findCourse(store.get(), args.courseId));
-			},
-			isConcurrencySafe: () => true,
-			presentCall: (args) => ({
-				card: "generic",
-				title: `Course map: ${args.courseId}`,
-				kind: "read"
-			}),
-			presentationMeta: (_args, value) => mapLines(value),
-			presentResult: (_args, result) => ({
-				card: "generic",
-				content: textBlocks(result.meta)
-			})
-		}),
-		defineTool({
-			name: "study_lesson",
-			description: "Open one lesson and make it the focus: returns its markdown content (the source of truth to teach from), teaching strategy band, knowledge concepts with mastery/weak flags, four consolidation starters, memory slots, and any pending mastery proposal.",
-			parameters: { lessonId: {
-				type: "string",
-				required: true,
-				description: "Lesson id from a map, import, or courses call."
-			} },
-			output: {
-				schema: {
-					type: "object",
-					additionalProperties: false,
-					properties: {
-						lessonId: {
-							type: "string",
-							required: true
-						},
-						courseId: {
-							type: "string",
-							required: true
-						},
-						courseTitle: {
-							type: "string",
-							required: true
-						},
-						sectionTitle: {
-							type: "string",
-							required: true
-						},
-						title: {
-							type: "string",
-							required: true
-						},
-						kind: {
-							type: "string",
-							required: true,
-							enum: [...LESSON_KINDS]
-						},
-						status: {
-							type: "string",
-							required: true,
-							enum: [...LESSON_STATUSES]
-						},
-						body: {
-							type: "string",
-							required: true
-						},
-						masteryPct: {
-							...nullableInteger,
-							required: true
-						},
-						crown: {
-							type: "integer",
-							required: true
-						},
-						attempts: {
-							type: "integer",
-							required: true
-						},
-						correctCount: {
-							type: "integer",
-							required: true
-						},
-						strategy: {
-							type: "string",
-							required: true
-						},
-						concepts: {
-							oneOf: [{ type: "null" }, {
-								type: "array",
-								items: {
-									type: "object",
-									additionalProperties: false,
-									properties: {
-										title: {
-											type: "string",
-											required: true
-										},
-										masteryPct: {
-											type: "integer",
-											required: true
-										},
-										weak: {
-											type: "boolean",
-											required: true
-										},
-										/** 1 once this concept has been quizzed at least once, else 0 (ConceptView.tested). */
-										tested: {
-											type: "integer",
-											required: true
-										}
-									}
-								}
-							}],
-							required: true
-						},
-						starters: {
-							type: "array",
-							required: true,
-							items: {
-								type: "object",
-								additionalProperties: false,
-								properties: {
-									label: {
-										type: "string",
-										required: true
-									},
-									message: {
-										type: "string",
-										required: true
-									},
-									effect: {
-										type: "string",
-										required: true,
-										enum: [
-											"mastery",
-											"friction",
-											"none"
-										]
-									}
-								}
+					},
+					progress: {
+						type: "object",
+						required: true,
+						additionalProperties: false,
+						description: "XP + streak block (upstream xp-service/streak semantics).",
+						properties: {
+							totalXp: {
+								type: "integer",
+								required: true
+							},
+							level: {
+								type: "integer",
+								required: true
+							},
+							levelPct: {
+								type: "integer",
+								required: true
+							},
+							todayXp: {
+								type: "integer",
+								required: true
+							},
+							dailyGoal: {
+								type: "integer",
+								required: true
+							},
+							streak: {
+								type: "integer",
+								required: true
+							},
+							longestStreak: {
+								type: "integer",
+								required: true
+							},
+							freezeCount: {
+								type: "integer",
+								required: true
 							}
-						},
-						memory: {
+						}
+					},
+					matches: {
+						type: "array",
+						description: "Full-text hits (present only when query was given).",
+						items: {
 							type: "object",
-							required: true,
 							additionalProperties: false,
 							properties: {
-								lesson: {
-									...nullableString,
+								courseId: {
+									type: "string",
 									required: true
 								},
-								global: {
-									...nullableString,
+								courseTitle: {
+									type: "string",
 									required: true
 								},
-								pattern: {
-									...nullableString,
+								lessonId: {
+									type: "string",
+									required: true
+								},
+								lessonTitle: {
+									type: "string",
+									required: true
+								},
+								snippet: {
+									type: "string",
 									required: true
 								}
 							}
-						},
-						noteCount: {
-							type: "integer",
-							required: true
-						},
-						pendingProposal: {
-							oneOf: [{ type: "null" }, {
-								type: "object",
-								additionalProperties: false,
-								properties: {
-									id: {
-										type: "string",
-										required: true
-									},
-									rationale: {
-										type: "string",
-										required: true
-									}
-								}
-							}],
-							required: true
-						},
-						nextLessonId: {
-							...nullableString,
-							required: true
 						}
 					}
-				},
-				render: (_args, value) => [{
-					type: "text",
-					text: `Lesson “${value.title}” — ${value.courseTitle} / ${value.sectionTitle}\nstatus ${value.status}${value.masteryPct === null ? "" : `, mastery ${value.masteryPct}%`}, ${value.correctCount}/${value.attempts} answers correct\nstrategy: ${value.strategy}\n` + (value.concepts === null ? "" : `concepts: ${value.concepts.map((c) => `${c.title} ${c.masteryPct}%${c.weak ? " ⚡weak" : ""}`).join(" · ")}\n`) + `starters: ${value.starters.map((s) => s.label).join(" / ")}\n\n${value.body}${value.nextLessonId === null ? "\n\n(this is the last lesson)" : `\n\n(next lesson: ${value.nextLessonId})`}`
-				}]
-			},
-			async execute(args) {
-				return mutate((state) => {
-					const { ref } = attemptLesson(state, args.lessonId, /* @__PURE__ */ new Date());
-					state.focus = { lessonId: ref.lesson.id };
-					return toLessonValue(ref, state);
-				});
-			},
-			presentCall: (args) => ({
-				card: "generic",
-				title: `Open lesson: ${args.lessonId}`,
-				kind: "read"
-			})
-		}),
-		defineTool({
-			name: "study_record_answer",
-			description: "Record one graded answer and update mastery — call after EVERY learner answer to a scored question. Name the `concept` the question tested (from study_lesson / study_define_concepts) so per-concept mastery stays accurate; lesson mastery is the WEAKEST concept. Mastery ≥50% unlocks the next lesson early; ≥90% graduates automatically and schedules the first review. Also pass the question text and the learner's answer to keep a practice log.",
-			parameters: {
-				lessonId: {
-					type: "string",
-					required: true,
-					description: "Lesson the question tested."
-				},
-				correct: {
-					type: "boolean",
-					required: true,
-					description: "Whether the learner answered correctly."
-				},
-				concept: {
-					type: "string",
-					description: "Concept title the question tested (required once concepts are defined)."
-				},
-				rationale: {
-					type: "string",
-					description: "One line: why you graded it this way."
-				},
-				question: {
-					type: "string",
-					description: "The question text, for the practice log."
-				},
-				givenAnswer: {
-					type: "string",
-					description: "The learner's answer, for the practice log."
 				}
 			},
-			output: {
-				schema: {
-					type: "object",
-					additionalProperties: false,
-					properties: {
-						lessonId: {
-							type: "string",
-							required: true
-						},
-						lessonTitle: {
-							type: "string",
-							required: true
-						},
-						correct: {
-							type: "boolean",
-							required: true
-						},
-						concept: {
-							oneOf: [{ type: "null" }, {
+			render: (_args, value) => [{
+				type: "text",
+				text: value.courses.length === 0 ? "No courses imported yet. Import one with study_import_markdown, study_import_folder, study_import_github, or study_import_url." : value.courses.map((c) => `[courseId ${c.courseId}] “${c.title}” (${c.source}) — ${c.mastered}/${c.total} lessons mastered${c.avgMasteryPct === null ? "" : `, avg mastery ${c.avgMasteryPct}%`}${c.dueCount === 0 ? "" : `, ${c.dueCount} reviews due`}${c.currentLessonId === null ? "" : `, current lesson ${c.currentLessonId}`}`).join("\n") + `\nXP ${value.progress.totalXp} (Lv${value.progress.level} ${value.progress.levelPct}%), today ${value.progress.todayXp}/${value.progress.dailyGoal}, streak ${value.progress.streak}d (best ${value.progress.longestStreak}d, ${value.progress.freezeCount} freeze left)` + (Array.isArray(value.matches) && value.matches.length > 0 ? `\nsearch hits (use study_lesson with the lessonId):\n${value.matches.map((m) => `- ${m.lessonTitle} [lessonId ${m.lessonId}] (${m.courseTitle}): ${m.snippet}`).join("\n")}` : "")
+			}]
+		},
+		async execute(args) {
+			const state = store.get();
+			const summaries = courseSummaries(state, /* @__PURE__ */ new Date());
+			const xp = levelFromTotalXp(state.xp.total);
+			return {
+				total: summaries.length,
+				courses: summaries.map((s) => ({
+					courseId: s.courseId,
+					title: s.title,
+					source: s.source,
+					total: s.total,
+					mastered: s.mastered,
+					avgMasteryPct: s.avgMasteryPct,
+					dueCount: s.dueCount,
+					currentLessonId: s.currentLessonId
+				})),
+				progress: {
+					totalXp: state.xp.total,
+					level: xp.level,
+					levelPct: xp.pct,
+					todayXp: state.xp.todayXp,
+					dailyGoal: 30,
+					streak: state.streak.currentStreak,
+					longestStreak: state.streak.longestStreak,
+					freezeCount: state.streak.freezeCount
+				},
+				...args.query !== void 0 ? { matches: searchLessons(state, args.query) } : {}
+			};
+		},
+		isConcurrencySafe: () => true,
+		presentCall: (args) => ({
+			card: "generic",
+			title: args.query === void 0 ? "List courses" : `Search lessons: ${args.query}`,
+			kind: "read"
+		})
+	});
+	const courseMap = defineTool({
+		name: "study_map",
+		description: "Show one course's skill tree: sections, lessons with locked/available/in_progress/mastered status, mastery, weak-concept count (⚡), and friction count — the weak spots to target.",
+		parameters: { courseId: {
+			type: "string",
+			required: true,
+			description: "Course id from an import result or study_courses."
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					courseId: {
+						type: "string",
+						required: true
+					},
+					title: {
+						type: "string",
+						required: true
+					},
+					counts: {
+						type: "object",
+						required: true,
+						additionalProperties: false,
+						properties: {
+							total: {
+								type: "integer",
+								required: true
+							},
+							mastered: {
+								type: "integer",
+								required: true
+							},
+							available: {
+								type: "integer",
+								required: true
+							}
+						}
+					},
+					tree: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								title: {
+									type: "string",
+									required: true
+								},
+								lessons: {
+									type: "array",
+									required: true,
+									items: {
+										type: "object",
+										additionalProperties: false,
+										properties: {
+											id: {
+												type: "string",
+												required: true
+											},
+											title: {
+												type: "string",
+												required: true
+											},
+											kind: {
+												type: "string",
+												required: true,
+												enum: [...LESSON_KINDS]
+											},
+											status: {
+												type: "string",
+												required: true,
+												enum: [...LESSON_STATUSES]
+											},
+											masteryPct: {
+												...nullableInteger,
+												required: true
+											},
+											crown: {
+												type: "integer",
+												required: true
+											},
+											weakConcepts: {
+												type: "integer",
+												required: true
+											},
+											frictionCount: {
+												type: "integer",
+												required: true
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			},
+			render: (_args, value) => textBlocks(mapLines(value))
+		},
+		async execute(args) {
+			return toMapValue(findCourse(store.get(), args.courseId));
+		},
+		isConcurrencySafe: () => true,
+		presentCall: (args) => ({
+			card: "generic",
+			title: `Course map: ${args.courseId}`,
+			kind: "read"
+		}),
+		presentationMeta: (_args, value) => mapLines(value),
+		presentResult: (_args, result) => ({
+			card: "generic",
+			content: textBlocks(result.meta)
+		})
+	});
+	const lessonContent = defineTool({
+		name: "study_lesson",
+		description: "Open one lesson and make it the focus: returns its markdown content (the source of truth to teach from), teaching strategy band, knowledge concepts with mastery/weak flags, four consolidation starters, memory slots, and any pending mastery proposal.",
+		parameters: { lessonId: {
+			type: "string",
+			required: true,
+			description: "Lesson id from a map, import, or courses call."
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					lessonId: {
+						type: "string",
+						required: true
+					},
+					courseId: {
+						type: "string",
+						required: true
+					},
+					courseTitle: {
+						type: "string",
+						required: true
+					},
+					sectionTitle: {
+						type: "string",
+						required: true
+					},
+					title: {
+						type: "string",
+						required: true
+					},
+					kind: {
+						type: "string",
+						required: true,
+						enum: [...LESSON_KINDS]
+					},
+					status: {
+						type: "string",
+						required: true,
+						enum: [...LESSON_STATUSES]
+					},
+					body: {
+						type: "string",
+						required: true
+					},
+					masteryPct: {
+						...nullableInteger,
+						required: true
+					},
+					crown: {
+						type: "integer",
+						required: true
+					},
+					attempts: {
+						type: "integer",
+						required: true
+					},
+					correctCount: {
+						type: "integer",
+						required: true
+					},
+					strategy: {
+						type: "string",
+						required: true
+					},
+					concepts: {
+						oneOf: [{ type: "null" }, {
+							type: "array",
+							items: {
 								type: "object",
 								additionalProperties: false,
 								properties: {
@@ -3790,480 +4985,1163 @@ function studyTools(store, deps = {}) {
 									weak: {
 										type: "boolean",
 										required: true
+									},
+									/** 1 once this concept has been quizzed at least once, else 0 (ConceptView.tested). */
+									tested: {
+										type: "integer",
+										required: true
 									}
 								}
-							}],
-							required: true
-						},
-						prevMasteryPct: {
-							type: "integer",
-							required: true
-						},
-						newMasteryPct: {
-							type: "integer",
-							required: true
-						},
-						crown: {
-							type: "integer",
-							required: true
-						},
-						mastered: {
-							type: "boolean",
-							required: true
-						},
-						attempts: {
-							type: "integer",
-							required: true
-						},
-						correctCount: {
-							type: "integer",
-							required: true
-						},
-						graduated: {
-							type: "boolean",
-							required: true
-						},
-						unlockedLessonIds: {
-							type: "array",
-							required: true,
-							items: { type: "string" }
-						},
-						reviewDueAt: {
-							...nullableString,
-							required: true
+							}
+						}],
+						required: true
+					},
+					starters: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								label: {
+									type: "string",
+									required: true
+								},
+								message: {
+									type: "string",
+									required: true
+								},
+								effect: {
+									type: "string",
+									required: true,
+									enum: [
+										"mastery",
+										"friction",
+										"none"
+									]
+								}
+							}
+						}
+					},
+					memory: {
+						type: "object",
+						required: true,
+						additionalProperties: false,
+						properties: {
+							lesson: {
+								...nullableString,
+								required: true
+							},
+							global: {
+								...nullableString,
+								required: true
+							},
+							pattern: {
+								...nullableString,
+								required: true
+							}
 						}
+					},
+					noteCount: {
+						type: "integer",
+						required: true
+					},
+					pendingProposal: {
+						oneOf: [{ type: "null" }, {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								id: {
+									type: "string",
+									required: true
+								},
+								rationale: {
+									type: "string",
+									required: true
+								}
+							}
+						}],
+						required: true
+					},
+					examGuide: {
+						type: "object",
+						description: "Exam nodes only: question quota, time-limit rule, star thresholds.",
+						additionalProperties: false,
+						properties: {
+							questionCount: {
+								type: "integer",
+								required: true
+							},
+							kcCount: {
+								type: "integer",
+								required: true
+							},
+							timeLimitRule: {
+								type: "string",
+								required: true
+							},
+							starsRule: {
+								type: "string",
+								required: true
+							},
+							bestStars: {
+								type: "integer",
+								required: true
+							},
+							examAttempts: {
+								type: "integer",
+								required: true
+							}
+						}
+					},
+					nextLessonId: {
+						...nullableString,
+						required: true
+					},
+					learnerState: {
+						type: "string",
+						required: true,
+						description: "Composed learner snapshot (status/mastery/weak/friction/memory)."
+					},
+					summary: {
+						type: "string",
+						description: "1–2 sentence lesson summary (defined with the concepts)."
 					}
-				},
-				render: (_args, value) => [{
-					type: "text",
-					text: answerLine(value) + (value.concept === null ? "" : `\nconcept: ${value.concept.title} ${value.concept.masteryPct}%${value.concept.weak ? " ⚡weak" : ""}`) + (value.graduated ? "\n🎓 mastery ≥90% — lesson graduated, first review scheduled." : "") + (value.unlockedLessonIds.length === 0 ? "" : `\n🔓 unlocked: ${value.unlockedLessonIds.join(", ")}`)
-				}]
+				}
 			},
-			async execute(args) {
-				return mutate((state) => {
-					const r = recordAnswer(state, args.lessonId, args.correct, args.concept, /* @__PURE__ */ new Date());
-					if (args.question !== void 0) addNote(state, args.lessonId, "practice", args.question.slice(0, 80), `${args.question}\n\nlearner answered: ${args.givenAnswer ?? "(not recorded)"} — ${args.correct ? "✓ correct" : "✗ incorrect"}${args.rationale === void 0 ? "" : `\nrationale: ${args.rationale}`}`, "ai", null, /* @__PURE__ */ new Date());
-					return {
-						lessonId: r.ref.lesson.id,
-						lessonTitle: r.ref.lesson.title,
-						correct: args.correct,
-						concept: r.concept === null ? null : {
-							title: r.concept.title,
-							masteryPct: Math.round(r.concept.mastery * 100),
-							weak: r.concept.mastery < .7
-						},
-						prevMasteryPct: Math.round(r.prevMastery * 100),
-						newMasteryPct: Math.round(r.newMastery * 100),
-						crown: r.crown,
-						mastered: r.mastered,
-						attempts: r.ref.lesson.attempts,
-						correctCount: r.ref.lesson.correctCount,
-						graduated: r.progression.graduated,
-						unlockedLessonIds: r.progression.unlocked.map((u) => u.id),
-						reviewDueAt: r.progression.nextDue
-					};
-				});
+			render: (_args, value) => [{
+				type: "text",
+				text: `Lesson “${value.title}” — ${value.courseTitle} / ${value.sectionTitle}\nstatus ${value.status}${value.masteryPct === null ? "" : `, mastery ${value.masteryPct}%`}, ${value.correctCount}/${value.attempts} answers correct\nstrategy: ${value.strategy}\n` + (value.concepts === null ? "" : `concepts: ${value.concepts.map((c) => `${c.title} ${c.masteryPct}%${c.weak ? " ⚡weak" : ""}`).join(" · ")}\n`) + (value.examGuide === void 0 ? "" : `exam: ${value.examGuide.questionCount} questions (${value.examGuide.kcCount} KCs); per-question time ${value.examGuide.timeLimitRule}; stars ${value.examGuide.starsRule}\n`) + `starters: ${value.starters.map((s) => s.label).join(" / ")}\n\n${value.body}${value.nextLessonId === null ? "\n\n(this is the last lesson)" : `\n\n(next lesson: ${value.nextLessonId})`}`
+			}]
+		},
+		async execute(args) {
+			return mutate((state) => {
+				const { ref } = attemptLesson(state, args.lessonId, /* @__PURE__ */ new Date());
+				state.focus = { lessonId: ref.lesson.id };
+				return toLessonValue(ref, state);
+			});
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: `Open lesson: ${args.lessonId}`,
+			kind: "read"
+		})
+	});
+	const recordAnswerTool = defineTool({
+		name: "study_record_answer",
+		description: "Record one graded answer and update mastery — call after EVERY learner answer to a scored question. Name the `concept` the question tested (from study_lesson / study_define_concepts) so per-concept mastery stays accurate; lesson mastery is the WEAKEST concept. Mastery ≥50% unlocks the next lesson early; ≥90% graduates automatically and schedules the first review. Also pass the question text and the learner's answer to keep a practice log.",
+		parameters: {
+			lessonId: {
+				type: "string",
+				required: true,
+				description: "Lesson the question tested."
 			},
-			presentCall: (args) => ({
-				card: "generic",
-				title: `Record answer (${args.correct ? "correct" : "incorrect"}): ${args.lessonId}`
-			}),
-			presentationMeta: (_args, value) => [answerLine(value)],
-			presentResult: (_args, result) => ({
-				card: "generic",
-				content: textBlocks(result.meta)
-			})
+			correct: {
+				type: "boolean",
+				required: true,
+				description: "Whether the learner answered correctly."
+			},
+			concept: {
+				type: "string",
+				description: "Concept title the question tested (required once concepts are defined)."
+			},
+			rationale: {
+				type: "string",
+				description: "One line: why you graded it this way."
+			},
+			question: {
+				type: "string",
+				description: "The question text, for the practice log."
+			},
+			givenAnswer: {
+				type: "string",
+				description: "The learner's answer, for the practice log."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					lessonId: {
+						type: "string",
+						required: true
+					},
+					lessonTitle: {
+						type: "string",
+						required: true
+					},
+					correct: {
+						type: "boolean",
+						required: true
+					},
+					concept: {
+						oneOf: [{ type: "null" }, {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								title: {
+									type: "string",
+									required: true
+								},
+								masteryPct: {
+									type: "integer",
+									required: true
+								},
+								weak: {
+									type: "boolean",
+									required: true
+								}
+							}
+						}],
+						required: true
+					},
+					prevMasteryPct: {
+						type: "integer",
+						required: true
+					},
+					newMasteryPct: {
+						type: "integer",
+						required: true
+					},
+					crown: {
+						type: "integer",
+						required: true
+					},
+					mastered: {
+						type: "boolean",
+						required: true
+					},
+					attempts: {
+						type: "integer",
+						required: true
+					},
+					correctCount: {
+						type: "integer",
+						required: true
+					},
+					graduated: {
+						type: "boolean",
+						required: true
+					},
+					unlockedLessonIds: {
+						type: "array",
+						required: true,
+						items: { type: "string" }
+					},
+					reviewDueAt: {
+						...nullableString,
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: answerLine(value) + (value.concept === null ? "" : `\nconcept: ${value.concept.title} ${value.concept.masteryPct}%${value.concept.weak ? " ⚡weak" : ""}`) + (value.graduated ? "\n🎓 mastery ≥90% — lesson graduated, first review scheduled." : "") + (value.unlockedLessonIds.length === 0 ? "" : `\n🔓 unlocked: ${value.unlockedLessonIds.join(", ")}`)
+			}]
+		},
+		async execute(args) {
+			return mutate((state) => {
+				const r = recordAnswer(state, args.lessonId, args.correct, args.concept, /* @__PURE__ */ new Date());
+				if (args.question !== void 0) addNote(state, args.lessonId, "practice", args.question.slice(0, 80), `${args.question}\n\nlearner answered: ${args.givenAnswer ?? "(not recorded)"} — ${args.correct ? "✓ correct" : "✗ incorrect"}${args.rationale === void 0 ? "" : `\nrationale: ${args.rationale}`}`, "ai", null, /* @__PURE__ */ new Date());
+				return {
+					lessonId: r.ref.lesson.id,
+					lessonTitle: r.ref.lesson.title,
+					correct: args.correct,
+					concept: r.concept === null ? null : {
+						title: r.concept.title,
+						masteryPct: Math.round(r.concept.mastery * 100),
+						weak: r.concept.mastery < .7
+					},
+					prevMasteryPct: Math.round(r.prevMastery * 100),
+					newMasteryPct: Math.round(r.newMastery * 100),
+					crown: r.crown,
+					mastered: r.mastered,
+					attempts: r.ref.lesson.attempts,
+					correctCount: r.ref.lesson.correctCount,
+					graduated: r.progression.graduated,
+					unlockedLessonIds: r.progression.unlocked.map((u) => u.id),
+					reviewDueAt: r.progression.nextDue
+				};
+			});
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: `Record answer (${args.correct ? "correct" : "incorrect"}): ${args.lessonId}`
 		}),
-		defineTool({
-			name: "study_complete_lesson",
-			description: "Mark a lesson mastered manually (graduation at 90% mastery is the automatic path — this is the override). Unlocks the next lesson and schedules the first spaced review for tomorrow. Call only when the learner has genuinely worked through the lesson.",
-			parameters: { lessonId: {
+		presentationMeta: (_args, value) => [answerLine(value)],
+		presentResult: (_args, result) => ({
+			card: "generic",
+			content: textBlocks(result.meta)
+		})
+	});
+	const examResultTool = defineTool({
+		name: "study_exam_result",
+		description: "Record one graded section-exam attempt: stars from accuracy (≥95%→3★, ≥80%→2★, ≥60%→1★, below→0; best-of retained across attempts) plus the post-quiz action set the learner should be offered next (explain-wrong / retry / go-deeper / mark-mastered→study_propose_mastery / next-topic). Call once per exam attempt after grading all questions.",
+		parameters: {
+			lessonId: {
+				type: "string",
+				required: true,
+				description: "The exam lesson node id."
+			},
+			correct: {
+				type: "integer",
+				required: true,
+				description: "Questions answered correctly."
+			},
+			total: {
+				type: "integer",
+				required: true,
+				description: "Questions asked in this attempt (must be > 0)."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					lessonId: {
+						type: "string",
+						required: true
+					},
+					lessonTitle: {
+						type: "string",
+						required: true
+					},
+					stars: {
+						type: "integer",
+						required: true
+					},
+					bestStars: {
+						type: "integer",
+						required: true
+					},
+					attempts: {
+						type: "integer",
+						required: true
+					},
+					masteryPct: {
+						type: "integer",
+						required: true
+					},
+					actions: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								id: {
+									type: "string",
+									enum: [
+										"explain-wrong",
+										"retry",
+										"go-deeper",
+										"mark-mastered",
+										"next-topic"
+									],
+									required: true
+								},
+								label: {
+									type: "string",
+									required: true
+								},
+								advancesMastery: { type: "boolean" }
+							}
+						}
+					},
+					nextLessonId: {
+						...nullableString,
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Exam result: ${value.stars}★ (best ${value.bestStars}★, attempt ${value.attempts}). Offer the learner: ${value.actions.map((a) => a.label).join(" / ")}.` + (value.nextLessonId === null ? "" : ` Next topic: ${value.nextLessonId}.`)
+			}]
+		},
+		execute(args) {
+			return mutate((state) => {
+				const r = recordExamResult(state, args.lessonId, args.correct, args.total);
+				const actions = getPostQuizActions({
+					correct: args.correct,
+					total: args.total
+				}, r.ref.lesson.mastery);
+				const flat = r.ref.course.sections.flatMap((s) => s.lessons);
+				const idx = flat.findIndex((l) => l.id === args.lessonId);
+				const next = flat.slice(idx + 1).find((l) => l.kind !== "exam" && l.status !== "locked") ?? null;
+				const labels = {
+					"explain-wrong": "讲解错题",
+					retry: "再来一组",
+					"go-deeper": "深入这个主题",
+					"mark-mastered": "标记掌握 (study_propose_mastery)",
+					"next-topic": next === null ? "下一课" : `下一课 (${next.title})`
+				};
+				return {
+					lessonId: r.ref.lesson.id,
+					lessonTitle: r.ref.lesson.title,
+					stars: r.stars,
+					bestStars: r.bestStars,
+					attempts: r.attempts,
+					masteryPct: Math.round((r.ref.lesson.mastery ?? 0) * 100),
+					actions: actions.map((a) => ({
+						id: a.id,
+						label: labels[a.id] ?? a.id,
+						...a.advancesMastery ? { advancesMastery: true } : {}
+					})),
+					nextLessonId: next === null ? null : next.id
+				};
+			});
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: `Exam result: ${args.correct}/${args.total}`
+		}),
+		presentationMeta: (_args, value) => [`${value.stars}★`],
+		presentResult: (_args, result) => ({
+			card: "generic",
+			content: textBlocks(result.meta)
+		})
+	});
+	const completeLessonTool = defineTool({
+		name: "study_complete_lesson",
+		description: "Mark a lesson mastered manually (graduation at 90% mastery is the automatic path — this is the override). Unlocks the next lesson and schedules the first spaced review for tomorrow. Call only when the learner has genuinely worked through the lesson.",
+		parameters: { lessonId: {
+			type: "string",
+			required: true,
+			description: "Lesson to complete."
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					lessonId: {
+						type: "string",
+						required: true
+					},
+					lessonTitle: {
+						type: "string",
+						required: true
+					},
+					unlockedLessonIds: {
+						type: "array",
+						required: true,
+						items: { type: "string" }
+					},
+					unlockedLessonTitles: {
+						type: "array",
+						required: true,
+						items: { type: "string" }
+					},
+					reviewDueAt: {
+						type: "string",
+						required: true
+					},
+					courseComplete: {
+						type: "boolean",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: completeLines(value).join("\n")
+			}]
+		},
+		async execute(args) {
+			return mutate((state) => {
+				const r = completeLesson(state, args.lessonId, /* @__PURE__ */ new Date());
+				return {
+					lessonId: r.ref.lesson.id,
+					lessonTitle: r.ref.lesson.title,
+					unlockedLessonIds: r.unlocked.map((u) => u.id),
+					unlockedLessonTitles: r.unlocked.map((u) => u.title),
+					reviewDueAt: r.dueAt,
+					courseComplete: r.courseComplete
+				};
+			});
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: `Complete lesson: ${args.lessonId}`
+		}),
+		presentationMeta: (_args, value) => completeLines(value),
+		presentResult: (_args, result) => ({
+			card: "generic",
+			content: textBlocks(result.meta)
+		})
+	});
+	const dueReviewsTool = defineTool({
+		name: "study_due_reviews",
+		description: "List mastered lessons whose spaced-repetition review is due (optionally within one course), oldest first. Start every session here.",
+		parameters: { courseId: {
+			type: "string",
+			description: "Restrict to one course; omit to scan all courses."
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					total: {
+						type: "integer",
+						required: true
+					},
+					due: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								lessonId: {
+									type: "string",
+									required: true
+								},
+								courseTitle: {
+									type: "string",
+									required: true
+								},
+								lessonTitle: {
+									type: "string",
+									required: true
+								},
+								dueAt: {
+									type: "string",
+									required: true
+								},
+								overdueDays: {
+									type: "integer",
+									required: true
+								}
+							}
+						}
+					}
+				}
+			},
+			render: (_args, value) => textBlocks(dueLines(value))
+		},
+		async execute(args) {
+			const due = dueReviews(store.get(), args.courseId, /* @__PURE__ */ new Date());
+			return {
+				total: due.length,
+				due: due.map((d) => ({
+					lessonId: d.lessonId,
+					courseTitle: d.courseTitle,
+					lessonTitle: d.lessonTitle,
+					dueAt: d.dueAt,
+					overdueDays: d.overdueDays
+				}))
+			};
+		},
+		isConcurrencySafe: () => true,
+		presentCall: () => ({
+			card: "generic",
+			title: "List due reviews",
+			kind: "search"
+		}),
+		presentationMeta: (_args, value) => dueLines(value),
+		presentResult: (_args, result) => ({
+			card: "generic",
+			content: textBlocks(result.meta)
+		})
+	});
+	const recordReviewTool = defineTool({
+		name: "study_record_review",
+		description: "Record an SM-2 review grade for a mastered lesson and advance its schedule. Grade how well the learner recalled the material: 5 perfect, 4 hesitant, 3 recalled with effort, 2 incorrect but recognized, 1 incorrect, 0 complete blackout. Target weak concepts (⚡) first.",
+		parameters: {
+			lessonId: {
+				type: "string",
+				required: true,
+				description: "Lesson being reviewed."
+			},
+			quality: {
+				type: "integer",
+				required: true,
+				enum: [...QUALITIES],
+				description: "SM-2 recall quality, 0 (blackout) to 5 (perfect)."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					lessonId: {
+						type: "string",
+						required: true
+					},
+					lessonTitle: {
+						type: "string",
+						required: true
+					},
+					quality: {
+						type: "integer",
+						required: true
+					},
+					intervalDays: {
+						type: "integer",
+						required: true
+					},
+					repetitions: {
+						type: "integer",
+						required: true
+					},
+					easeFactor: {
+						type: "number",
+						required: true
+					},
+					dueAt: {
+						type: "string",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: reviewLine(value)
+			}]
+		},
+		async execute(args) {
+			return mutate((state) => {
+				const r = recordReview(state, args.lessonId, args.quality, /* @__PURE__ */ new Date());
+				return {
+					lessonId: r.ref.lesson.id,
+					lessonTitle: r.ref.lesson.title,
+					quality: args.quality,
+					intervalDays: r.intervalDays,
+					repetitions: r.repetitions,
+					easeFactor: r.easeFactor,
+					dueAt: r.dueAt
+				};
+			});
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: `Record review (quality ${args.quality}): ${args.lessonId}`
+		}),
+		presentationMeta: (_args, value) => [reviewLine(value)],
+		presentResult: (_args, result) => ({
+			card: "generic",
+			content: textBlocks(result.meta)
+		})
+	});
+	const deleteCourseTool = defineTool({
+		name: "study_delete_course",
+		description: "Delete one course and all its progress. Ask the learner before calling.",
+		parameters: { courseId: {
+			type: "string",
+			required: true,
+			description: "Course to delete."
+		} },
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					deletedCourseId: {
+						type: "string",
+						required: true
+					},
+					remaining: {
+						type: "integer",
+						required: true
+					}
+				}
+			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Deleted course ${value.deletedCourseId}. ${value.remaining} courses remain.`
+			}]
+		},
+		async execute(args) {
+			return mutate((state) => {
+				findCourse(state, args.courseId);
+				deleteCourse(state, args.courseId);
+				return {
+					deletedCourseId: args.courseId,
+					remaining: state.courses.length
+				};
+			});
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: `Delete course: ${args.courseId}`,
+			kind: "delete",
+			rawInput: args.courseId
+		})
+	});
+	const defineConceptsTool = defineTool({
+		name: "study_define_concepts",
+		description: "Define a lesson's knowledge components — the 2–7 independently quizzable units mastery tracks. Call this the FIRST time you teach a lesson, derived from its content. Titles ≤10 characters; descriptions say what understanding this concept means. Lesson mastery is the WEAKEST concept; cover weak ones (⚡) first when quizzing.",
+		parameters: {
+			lessonId: {
 				type: "string",
 				required: true,
-				description: "Lesson to complete."
-			} },
-			output: {
-				schema: {
+				description: "Lesson to describe."
+			},
+			concepts: {
+				type: "array",
+				required: true,
+				description: "2–7 concepts.",
+				items: {
 					type: "object",
 					additionalProperties: false,
 					properties: {
-						lessonId: {
-							type: "string",
-							required: true
-						},
-						lessonTitle: {
+						title: {
 							type: "string",
-							required: true
-						},
-						unlockedLessonIds: {
-							type: "array",
-							required: true,
-							items: { type: "string" }
-						},
-						unlockedLessonTitles: {
-							type: "array",
 							required: true,
-							items: { type: "string" }
+							description: "Short concept title."
 						},
-						reviewDueAt: {
+						description: {
 							type: "string",
-							required: true
-						},
-						courseComplete: {
-							type: "boolean",
-							required: true
+							required: true,
+							description: "One line: what understanding this concept means."
 						}
 					}
-				},
-				render: (_args, value) => [{
-					type: "text",
-					text: completeLines(value).join("\n")
-				}]
-			},
-			async execute(args) {
-				return mutate((state) => {
-					const r = completeLesson(state, args.lessonId, /* @__PURE__ */ new Date());
-					return {
-						lessonId: r.ref.lesson.id,
-						lessonTitle: r.ref.lesson.title,
-						unlockedLessonIds: r.unlocked.map((u) => u.id),
-						unlockedLessonTitles: r.unlocked.map((u) => u.title),
-						reviewDueAt: r.dueAt,
-						courseComplete: r.courseComplete
-					};
-				});
+				}
 			},
-			presentCall: (args) => ({
-				card: "generic",
-				title: `Complete lesson: ${args.lessonId}`
-			}),
-			presentationMeta: (_args, value) => completeLines(value),
-			presentResult: (_args, result) => ({
-				card: "generic",
-				content: textBlocks(result.meta)
-			})
-		}),
-		defineTool({
-			name: "study_due_reviews",
-			description: "List mastered lessons whose spaced-repetition review is due (optionally within one course), oldest first. Start every session here.",
-			parameters: { courseId: {
+			summary: {
 				type: "string",
-				description: "Restrict to one course; omit to scan all courses."
-			} },
-			output: {
-				schema: {
-					type: "object",
-					additionalProperties: false,
-					properties: {
-						total: {
-							type: "integer",
-							required: true
-						},
-						due: {
-							type: "array",
-							required: true,
-							items: {
-								type: "object",
-								additionalProperties: false,
-								properties: {
-									lessonId: {
-										type: "string",
-										required: true
-									},
-									courseTitle: {
-										type: "string",
-										required: true
-									},
-									lessonTitle: {
-										type: "string",
-										required: true
-									},
-									dueAt: {
-										type: "string",
-										required: true
-									},
-									overdueDays: {
-										type: "integer",
-										required: true
-									}
+				description: "Optional 1–2 sentence lesson summary (upstream lesson-summary-kc: generated once alongside the concepts)."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					lessonId: {
+						type: "string",
+						required: true
+					},
+					concepts: {
+						type: "array",
+						required: true,
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								title: {
+									type: "string",
+									required: true
+								},
+								masteryPct: {
+									type: "integer",
+									required: true
 								}
 							}
 						}
 					}
-				},
-				render: (_args, value) => textBlocks(dueLines(value))
+				}
 			},
-			async execute(args) {
-				const due = dueReviews(store.get(), args.courseId, /* @__PURE__ */ new Date());
+			render: (_args, value) => [{
+				type: "text",
+				text: `Concepts defined: ${value.concepts.map((c) => `${c.title} (${c.masteryPct}%)`).join(" · ")}. Attribute quiz answers with the \`concept\` parameter.`
+			}]
+		},
+		async execute(args) {
+			return mutate((state) => {
+				defineConcepts(state, args.lessonId, args.concepts, args.summary);
+				const ref = findLesson(state, args.lessonId);
 				return {
-					total: due.length,
-					due: due.map((d) => ({
-						lessonId: d.lessonId,
-						courseTitle: d.courseTitle,
-						lessonTitle: d.lessonTitle,
-						dueAt: d.dueAt,
-						overdueDays: d.overdueDays
+					lessonId: ref.lesson.id,
+					concepts: (conceptViews(ref.lesson) ?? []).map((c) => ({
+						title: c.title,
+						masteryPct: c.masteryPct
 					}))
 				};
+			});
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: `Define concepts: ${args.lessonId}`
+		})
+	});
+	const proposeMasteryTool = defineTool({
+		name: "study_propose_mastery",
+		description: "Propose graduating a lesson as mastered ahead of the 90% threshold — use when mastery is ≥85% and the learner has convincingly demonstrated understanding (e.g. a Feynman-style explanation back to you). Creates a PENDING proposal: present it with your rationale and WAIT for the learner's decision, then resolve with study_resolve_proposal. Never apply it yourself.",
+		parameters: {
+			lessonId: {
+				type: "string",
+				required: true,
+				description: "Lesson judged mastered."
 			},
-			isConcurrencySafe: () => true,
-			presentCall: () => ({
-				card: "generic",
-				title: "List due reviews",
-				kind: "search"
-			}),
-			presentationMeta: (_args, value) => dueLines(value),
-			presentResult: (_args, result) => ({
-				card: "generic",
-				content: textBlocks(result.meta)
-			})
-		}),
-		defineTool({
-			name: "study_record_review",
-			description: "Record an SM-2 review grade for a mastered lesson and advance its schedule. Grade how well the learner recalled the material: 5 perfect, 4 hesitant, 3 recalled with effort, 2 incorrect but recognized, 1 incorrect, 0 complete blackout. Target weak concepts (⚡) first.",
-			parameters: {
-				lessonId: {
-					type: "string",
-					required: true,
-					description: "Lesson being reviewed."
-				},
-				quality: {
-					type: "integer",
-					required: true,
-					enum: [...QUALITIES],
-					description: "SM-2 recall quality, 0 (blackout) to 5 (perfect)."
+			rationale: {
+				type: "string",
+				required: true,
+				description: "Why you believe it is mastered — the learner reads this."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					proposalId: {
+						type: "string",
+						required: true
+					},
+					lessonTitle: {
+						type: "string",
+						required: true
+					},
+					status: {
+						type: "string",
+						required: true,
+						enum: [
+							"pending",
+							"applied",
+							"rejected"
+						]
+					},
+					rationale: {
+						type: "string",
+						required: true
+					}
 				}
 			},
-			output: {
-				schema: {
-					type: "object",
-					additionalProperties: false,
-					properties: {
-						lessonId: {
-							type: "string",
-							required: true
-						},
-						lessonTitle: {
-							type: "string",
-							required: true
-						},
-						quality: {
-							type: "integer",
-							required: true
-						},
-						intervalDays: {
-							type: "integer",
-							required: true
-						},
-						repetitions: {
-							type: "integer",
-							required: true
-						},
-						easeFactor: {
-							type: "number",
-							required: true
-						},
-						dueAt: {
-							type: "string",
-							required: true
-						}
-					}
-				},
-				render: (_args, value) => [{
-					type: "text",
-					text: reviewLine(value)
-				}]
+			render: (_args, value) => [{
+				type: "text",
+				text: `Proposal ${value.proposalId} (${value.status}): “${value.lessonTitle}” — ${value.rationale}\nPresent this to the learner and wait; resolve via study_resolve_proposal.`
+			}]
+		},
+		async execute(args) {
+			return mutate((state) => {
+				const ref = findLesson(state, args.lessonId);
+				const proposal = proposeMastery(state, args.lessonId, args.rationale, /* @__PURE__ */ new Date());
+				return {
+					proposalId: proposal.id,
+					lessonTitle: ref.lesson.title,
+					status: proposal.status,
+					rationale: proposal.rationale
+				};
+			});
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: `Propose mastery: ${args.lessonId}`
+		}),
+		presentationMeta: (_args, value) => ({
+			kind: "study-proposal-created",
+			proposalId: value.proposalId,
+			lessonTitle: value.lessonTitle,
+			rationale: value.rationale
+		}),
+		presentResult: (_args, result) => ({
+			card: "generic",
+			content: textBlocks([`🎓 Proposed mastery for “${result.meta?.lessonTitle ?? "lesson"}”: ${result.meta?.rationale ?? ""}`])
+		})
+	});
+	const resolveProposalTool = defineTool({
+		name: "study_resolve_proposal",
+		description: "Resolve a pending mastery proposal with the learner's explicit decision (they said yes / no in chat). Accepting floors every concept to 95%, graduates the lesson, and unlocks the next one.",
+		parameters: {
+			proposalId: {
+				type: "string",
+				required: true,
+				description: "Proposal id from study_propose_mastery."
 			},
-			async execute(args) {
-				return mutate((state) => {
-					const r = recordReview(state, args.lessonId, args.quality, /* @__PURE__ */ new Date());
-					return {
-						lessonId: r.ref.lesson.id,
-						lessonTitle: r.ref.lesson.title,
-						quality: args.quality,
-						intervalDays: r.intervalDays,
-						repetitions: r.repetitions,
-						easeFactor: r.easeFactor,
-						dueAt: r.dueAt
-					};
-				});
+			accept: {
+				type: "boolean",
+				required: true,
+				description: "The learner's decision."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					proposalId: {
+						type: "string",
+						required: true
+					},
+					lessonId: {
+						type: "string",
+						required: true
+					},
+					status: {
+						type: "string",
+						required: true,
+						enum: ["applied", "rejected"]
+					}
+				}
 			},
-			presentCall: (args) => ({
-				card: "generic",
-				title: `Record review (quality ${args.quality}): ${args.lessonId}`
-			}),
-			presentationMeta: (_args, value) => [reviewLine(value)],
-			presentResult: (_args, result) => ({
-				card: "generic",
-				content: textBlocks(result.meta)
-			})
+			render: (_args, value) => [{
+				type: "text",
+				text: value.status === "applied" ? `🎓 Proposal applied — lesson ${value.lessonId} mastered (all concepts ≥95%), next lesson unlocked, review scheduled.` : `Proposal rejected — continuing practice on ${value.lessonId}.`
+			}]
+		},
+		async execute(args) {
+			return mutate((state) => {
+				const proposal = resolveProposal(state, args.proposalId, args.accept, /* @__PURE__ */ new Date());
+				return {
+					proposalId: proposal.id,
+					lessonId: proposal.lessonId,
+					status: proposal.status
+				};
+			});
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: `Resolve proposal: ${args.proposalId}`
 		}),
-		defineTool({
-			name: "study_delete_course",
-			description: "Delete one course and all its progress. Ask the learner before calling.",
-			parameters: { courseId: {
+		presentationMeta: (_args, value) => ({
+			kind: "study-proposal-resolved",
+			proposalId: value.proposalId,
+			status: value.status
+		}),
+		presentResult: (_args, result) => ({
+			card: "generic",
+			content: textBlocks([`Proposal ${result.meta?.proposalId ?? "?"} ${result.meta?.status ?? ""}.`])
+		})
+	});
+	const reportFrictionTool = defineTool({
+		name: "study_report_friction",
+		description: "SILENTLY log a learning-friction moment — call when the learner seems confused (糊涂), stuck (卡住), or frustrated (受挫), or when they say \"我没太懂\". One short line. Never mention that you logged it; it feeds the weak-spot map and adapts difficulty.",
+		parameters: {
+			category: {
+				type: "string",
+				required: true,
+				enum: [...FRICTION_CATEGORIES],
+				description: "confused | blocked | frustrated."
+			},
+			summary: {
+				type: "string",
+				description: "One short line: what specifically is hard."
+			},
+			lessonId: {
+				type: "string",
+				description: "Lesson it happened on, when known."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: { logged: {
+					type: "boolean",
+					required: true
+				} }
+			},
+			render: () => [{
+				type: "text",
+				text: "Noted."
+			}]
+		},
+		async execute(args) {
+			return mutate((state) => {
+				addFriction(state, args.lessonId ?? null, args.category, args.summary ?? null, /* @__PURE__ */ new Date());
+				return { logged: true };
+			});
+		},
+		presentCall: () => ({
+			card: "generic",
+			title: "Log friction"
+		})
+	});
+	const rememberTool = defineTool({
+		name: "study_remember",
+		description: "Write a learner-memory slot — call only when you learn something worth keeping across sessions (how they best learn, a recurring pattern, a specific gap). NOT for transient chat. To merge: read the current slot first (study_lesson's memory field), then send the merged 1–3 sentence version — this REPLACES the slot.",
+		parameters: {
+			category: {
+				type: "string",
+				required: true,
+				enum: [...MEMORY_CATEGORIES],
+				description: "global (cross-course style) | pattern (per-course recurring pattern) | lesson (this lesson's specific gap)."
+			},
+			content: {
+				type: "string",
+				required: true,
+				description: "The merged 1–3 sentence slot content."
+			},
+			lessonId: {
+				type: "string",
+				description: "Lesson (for the lesson slot) or any lesson of the course (for the pattern slot)."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					previous: {
+						...nullableString,
+						required: true
+					},
+					stored: {
+						type: "string",
+						required: true
+					}
+				}
+			},
+			render: () => [{
+				type: "text",
+				text: "Remembered."
+			}]
+		},
+		async execute(args) {
+			return mutate((state) => ({
+				previous: setMemory(state, args.category, args.content, args.lessonId),
+				stored: args.content
+			}));
+		},
+		presentCall: () => ({
+			card: "generic",
+			title: "Update learner memory"
+		})
+	});
+	const translateLessonTool = defineTool({
+		name: "study_translate_lesson",
+		description: "Write your translation of one lesson (the tutor IS the translator — upstream runs a model client, the plugin has none). The stored translation renders as a bilingual interleaved blackboard: each original paragraph followed by its translation. Translate faithfully at paragraph granularity so the pairing reads tightly.",
+		parameters: {
+			lessonId: {
 				type: "string",
 				required: true,
-				description: "Course to delete."
-			} },
-			output: {
-				schema: {
-					type: "object",
-					additionalProperties: false,
-					properties: {
-						deletedCourseId: {
-							type: "string",
-							required: true
-						},
-						remaining: {
-							type: "integer",
-							required: true
-						}
-					}
-				},
-				render: (_args, value) => [{
-					type: "text",
-					text: `Deleted course ${value.deletedCourseId}. ${value.remaining} courses remain.`
-				}]
+				description: "Lesson to translate."
 			},
-			async execute(args) {
-				return mutate((state) => {
-					findCourse(state, args.courseId);
-					deleteCourse(state, args.courseId);
-					return {
-						deletedCourseId: args.courseId,
-						remaining: state.courses.length
-					};
-				});
+			markdown: {
+				type: "string",
+				required: true,
+				description: "The full translated lesson body (markdown, paragraph-aligned with the original)."
 			},
-			presentCall: (args) => ({
-				card: "generic",
-				title: `Delete course: ${args.courseId}`,
-				kind: "delete",
-				rawInput: args.courseId
-			})
-		}),
-		defineTool({
-			name: "study_define_concepts",
-			description: "Define a lesson's knowledge components — the 2–7 independently quizzable units mastery tracks. Call this the FIRST time you teach a lesson, derived from its content. Titles ≤10 characters; descriptions say what understanding this concept means. Lesson mastery is the WEAKEST concept; cover weak ones (⚡) first when quizzing.",
-			parameters: {
-				lessonId: {
-					type: "string",
-					required: true,
-					description: "Lesson to describe."
-				},
-				concepts: {
-					type: "array",
-					required: true,
-					description: "2–7 concepts.",
-					items: {
-						type: "object",
-						additionalProperties: false,
-						properties: {
-							title: {
-								type: "string",
-								required: true,
-								description: "Short concept title (≤10 chars)."
-							},
-							description: {
-								type: "string",
-								required: true,
-								description: "What understanding this concept means."
-							}
-						}
+			lang: {
+				type: "string",
+				required: true,
+				description: "Language code or name, e.g. zh-CN / 中文."
+			}
+		},
+		output: {
+			schema: {
+				type: "object",
+				additionalProperties: false,
+				properties: {
+					lessonId: {
+						type: "string",
+						required: true
+					},
+					lessonTitle: {
+						type: "string",
+						required: true
+					},
+					lang: {
+						type: "string",
+						required: true
+					},
+					chars: {
+						type: "integer",
+						required: true
 					}
 				}
 			},
+			render: (_args, value) => [{
+				type: "text",
+				text: `Translation stored for “${value.lessonTitle}” (${value.lang}, ${value.chars} chars) — the blackboard now interleaves the original with it.`
+			}]
+		},
+		execute(args) {
+			return mutate((state) => {
+				const ref = findLesson(state, args.lessonId);
+				if (args.markdown.trim() === "") throw new Error("lookatstudy-plugin: translation markdown is empty");
+				ref.lesson.translation = args.markdown;
+				ref.lesson.translationLang = args.lang;
+				return {
+					lessonId: ref.lesson.id,
+					lessonTitle: ref.lesson.title,
+					lang: args.lang,
+					chars: args.markdown.length
+				};
+			});
+		},
+		presentCall: (args) => ({
+			card: "generic",
+			title: `Translate lesson: ${args.lessonId} → ${args.lang}`
+		})
+	});
+	return [
+		importMarkdown,
+		importFolder,
+		importGithub,
+		importUrl,
+		applyDesign,
+		listCourses,
+		courseMap,
+		lessonContent,
+		recordAnswerTool,
+		examResultTool,
+		completeLessonTool,
+		dueReviewsTool,
+		recordReviewTool,
+		deleteCourseTool,
+		defineConceptsTool,
+		proposeMasteryTool,
+		resolveProposalTool,
+		reportFrictionTool,
+		rememberTool,
+		defineTool({
+			name: "study_consolidate",
+			description: "Gather the consolidation window — friction entries and practice notes recorded since the last consolidation — and advance the watermark. You are the consolidation function (upstream runs an LLM call; here the tutor IS it): distill the window into 0–3 durable memory writes via study_remember (global style / per-course pattern / lesson-specific gaps), then tell the learner in one short line what you took away. Call when a session accumulates friction or after heavy quizzing — not every turn.",
+			parameters: {},
 			output: {
 				schema: {
 					type: "object",
 					additionalProperties: false,
 					properties: {
-						lessonId: {
-							type: "string",
+						since: {
+							...nullableString,
 							required: true
 						},
-						concepts: {
+						entries: {
 							type: "array",
 							required: true,
 							items: {
 								type: "object",
 								additionalProperties: false,
 								properties: {
-									title: {
+									lessonId: {
 										type: "string",
 										required: true
 									},
-									masteryPct: {
-										type: "integer",
+									lessonTitle: {
+										type: "string",
+										required: true
+									},
+									kind: {
+										type: "string",
+										required: true,
+										enum: ["friction", "practice"]
+									},
+									category: { type: "string" },
+									text: {
+										type: "string",
+										required: true
+									},
+									at: {
+										type: "string",
 										required: true
 									}
 								}
 							}
-						}
-					}
-				},
-				render: (_args, value) => [{
-					type: "text",
-					text: `Concepts defined: ${value.concepts.map((c) => `${c.title} (${c.masteryPct}%)`).join(" · ")}. Attribute quiz answers with the \`concept\` parameter.`
-				}]
-			},
-			async execute(args) {
-				return mutate((state) => {
-					defineConcepts(state, args.lessonId, args.concepts);
-					const ref = findLesson(state, args.lessonId);
-					return {
-						lessonId: ref.lesson.id,
-						concepts: (conceptViews(ref.lesson) ?? []).map((c) => ({
-							title: c.title,
-							masteryPct: c.masteryPct
-						}))
-					};
-				});
-			},
-			presentCall: (args) => ({
-				card: "generic",
-				title: `Define concepts: ${args.lessonId}`
-			})
-		}),
-		defineTool({
-			name: "study_propose_mastery",
-			description: "Propose graduating a lesson as mastered ahead of the 90% threshold — use when mastery is ≥85% and the learner has convincingly demonstrated understanding (e.g. a Feynman-style explanation back to you). Creates a PENDING proposal: present it with your rationale and WAIT for the learner's decision, then resolve with study_resolve_proposal. Never apply it yourself.",
-			parameters: {
-				lessonId: {
-					type: "string",
-					required: true,
-					description: "Lesson judged mastered."
-				},
-				rationale: {
-					type: "string",
-					required: true,
-					description: "Why you believe it is mastered — the learner reads this."
-				}
-			},
-			output: {
-				schema: {
-					type: "object",
-					additionalProperties: false,
-					properties: {
-						proposalId: {
-							type: "string",
-							required: true
-						},
-						lessonTitle: {
-							type: "string",
-							required: true
 						},
-						status: {
-							type: "string",
+						counts: {
+							type: "object",
 							required: true,
-							enum: [
-								"pending",
-								"applied",
-								"rejected"
-							]
+							additionalProperties: false,
+							properties: {
+								friction: {
+									type: "integer",
+									required: true
+								},
+								practice: {
+									type: "integer",
+									required: true
+								}
+							}
 						},
-						rationale: {
+						watermark: {
 							type: "string",
 							required: true
 						}
@@ -4271,193 +6149,87 @@ function studyTools(store, deps = {}) {
 				},
 				render: (_args, value) => [{
 					type: "text",
-					text: `Proposal ${value.proposalId} (${value.status}): “${value.lessonTitle}” — ${value.rationale}\nPresent this to the learner and wait; resolve via study_resolve_proposal.`
+					text: `Consolidation window since ${value.since ?? "(beginning)"}: ${value.counts.friction} friction, ${value.counts.practice} practice entries.` + (value.entries.length === 0 ? " Nothing to distill — tell the learner their memory is up to date." : " Distill these into 0–3 study_remember writes (global / pattern / lesson), then summarize in one line.")
 				}]
 			},
-			async execute(args) {
+			execute() {
 				return mutate((state) => {
-					const ref = findLesson(state, args.lessonId);
-					const proposal = proposeMastery(state, args.lessonId, args.rationale, /* @__PURE__ */ new Date());
+					const window = gatherConsolidationWindow(state);
+					const watermark = (/* @__PURE__ */ new Date()).toISOString();
+					state.lastConsolidatedAt = watermark;
 					return {
-						proposalId: proposal.id,
-						lessonTitle: ref.lesson.title,
-						status: proposal.status,
-						rationale: proposal.rationale
+						since: window.since,
+						entries: window.entries,
+						counts: window.counts,
+						watermark
 					};
 				});
 			},
-			presentCall: (args) => ({
-				card: "generic",
-				title: `Propose mastery: ${args.lessonId}`
-			}),
-			presentationMeta: (_args, value) => ({
-				kind: "study-proposal-created",
-				proposalId: value.proposalId,
-				lessonTitle: value.lessonTitle,
-				rationale: value.rationale
-			}),
-			presentResult: (_args, result) => ({
+			presentCall: () => ({
 				card: "generic",
-				content: textBlocks([`🎓 Proposed mastery for “${result.meta?.lessonTitle ?? "lesson"}”: ${result.meta?.rationale ?? ""}`])
+				title: "Consolidate learner memory"
 			})
 		}),
+		translateLessonTool,
 		defineTool({
-			name: "study_resolve_proposal",
-			description: "Resolve a pending mastery proposal with the learner's explicit decision (they said yes / no in chat). Accepting floors every concept to 95%, graduates the lesson, and unlocks the next one.",
-			parameters: {
-				proposalId: {
-					type: "string",
-					required: true,
-					description: "Proposal id from study_propose_mastery."
-				},
-				accept: {
-					type: "boolean",
-					required: true,
-					description: "The learner's decision."
-				}
-			},
+			name: "study_export",
+			description: "Export one course as a single markdown learning pack (upstream pack-export, zero-LLM): sections and lesson bodies verbatim. The receiver imports it anywhere through study_import_markdown — same plugin, fresh machine, no network. Present the pack to the learner (a copyable block) or save it into the study workspace when they ask for a file.",
+			parameters: { courseId: {
+				type: "string",
+				required: true,
+				description: "Course id to export."
+			} },
 			output: {
 				schema: {
 					type: "object",
 					additionalProperties: false,
 					properties: {
-						proposalId: {
+						courseId: {
 							type: "string",
 							required: true
 						},
-						lessonId: {
+						title: {
 							type: "string",
 							required: true
 						},
-						status: {
-							type: "string",
-							required: true,
-							enum: ["applied", "rejected"]
-						}
-					}
-				},
-				render: (_args, value) => [{
-					type: "text",
-					text: value.status === "applied" ? `🎓 Proposal applied — lesson ${value.lessonId} mastered (all concepts ≥95%), next lesson unlocked, review scheduled.` : `Proposal rejected — continuing practice on ${value.lessonId}.`
-				}]
-			},
-			async execute(args) {
-				return mutate((state) => {
-					const proposal = resolveProposal(state, args.proposalId, args.accept, /* @__PURE__ */ new Date());
-					return {
-						proposalId: proposal.id,
-						lessonId: proposal.lessonId,
-						status: proposal.status
-					};
-				});
-			},
-			presentCall: (args) => ({
-				card: "generic",
-				title: `Resolve proposal: ${args.proposalId}`
-			}),
-			presentationMeta: (_args, value) => ({
-				kind: "study-proposal-resolved",
-				proposalId: value.proposalId,
-				status: value.status
-			}),
-			presentResult: (_args, result) => ({
-				card: "generic",
-				content: textBlocks([`Proposal ${result.meta?.proposalId ?? "?"} ${result.meta?.status ?? ""}.`])
-			})
-		}),
-		defineTool({
-			name: "study_report_friction",
-			description: "SILENTLY log a learning-friction moment — call when the learner seems confused (糊涂), stuck (卡住), or frustrated (受挫), or when they say \"我没太懂\". One short line. Never mention that you logged it; it feeds the weak-spot map and adapts difficulty.",
-			parameters: {
-				category: {
-					type: "string",
-					required: true,
-					enum: [...FRICTION_CATEGORIES],
-					description: "confused | blocked | frustrated."
-				},
-				summary: {
-					type: "string",
-					description: "One short line: what specifically is hard."
-				},
-				lessonId: {
-					type: "string",
-					description: "Lesson it happened on, when known."
-				}
-			},
-			output: {
-				schema: {
-					type: "object",
-					additionalProperties: false,
-					properties: { logged: {
-						type: "boolean",
-						required: true
-					} }
-				},
-				render: () => [{
-					type: "text",
-					text: "Noted."
-				}]
-			},
-			async execute(args) {
-				return mutate((state) => {
-					addFriction(state, args.lessonId ?? null, args.category, args.summary ?? null, /* @__PURE__ */ new Date());
-					return { logged: true };
-				});
-			},
-			presentCall: () => ({
-				card: "generic",
-				title: "Log friction"
-			})
-		}),
-		defineTool({
-			name: "study_remember",
-			description: "Write a learner-memory slot — call only when you learn something worth keeping across sessions (how they best learn, a recurring pattern, a specific gap). NOT for transient chat. To merge: read the current slot first (study_lesson's memory field), then send the merged 1–3 sentence version — this REPLACES the slot.",
-			parameters: {
-				category: {
-					type: "string",
-					required: true,
-					enum: [...MEMORY_CATEGORIES],
-					description: "global (cross-course style) | pattern (per-course recurring pattern) | lesson (this lesson's specific gap)."
-				},
-				content: {
-					type: "string",
-					required: true,
-					description: "The merged 1–3 sentence slot content."
-				},
-				lessonId: {
-					type: "string",
-					description: "Lesson (for the lesson slot) or any lesson of the course (for the pattern slot)."
-				}
-			},
-			output: {
-				schema: {
-					type: "object",
-					additionalProperties: false,
-					properties: {
-						previous: {
-							...nullableString,
+						lessonCount: {
+							type: "integer",
 							required: true
 						},
-						stored: {
+						chars: {
+							type: "integer",
+							required: true
+						},
+						markdown: {
 							type: "string",
 							required: true
 						}
 					}
 				},
-				render: () => [{
+				render: (_args, value) => [{
 					type: "text",
-					text: "Remembered."
+					text: `Course pack “${value.title}” — ${value.lessonCount} lessons, ${value.chars} chars. Give the learner the markdown below (copyable); importing it goes through study_import_markdown.
+
+` + value.markdown
 				}]
 			},
-			async execute(args) {
-				return mutate((state) => ({
-					previous: setMemory(state, args.category, args.content, args.lessonId),
-					stored: args.content
-				}));
+			execute(args) {
+				const course = findCourse(store.get(), args.courseId);
+				const markdown = courseToPackMarkdown(course);
+				const lessonCount = course.sections.reduce((n, sec) => n + sec.lessons.filter((l) => l.kind !== "exam").length, 0);
+				return {
+					courseId: course.id,
+					title: course.title,
+					lessonCount,
+					chars: markdown.length,
+					markdown
+				};
 			},
-			presentCall: () => ({
+			isConcurrencySafe: () => true,
+			presentCall: (args) => ({
 				card: "generic",
-				title: "Update learner memory"
+				title: `Export course: ${args.courseId}`,
+				kind: "read"
 			})
 		}),
 		defineTool({
@@ -4743,7 +6515,7 @@ function snapshotSectionText(state) {
 	const snap = learnerSnapshot(state, /* @__PURE__ */ new Date());
 	if (snap.focus === null) return snap.dueCount === 0 ? "" : `【学习者当前状态】\n今日待复习: ${snap.dueCount} 项(study_due_reviews)`;
 	const lines = ["【学习者当前状态】"];
-	lines.push(`焦点: ${snap.focus.courseTitle} / ${snap.focus.lessonTitle}(${snap.focus.status}${snap.focus.masteryPct === null ? "" : `, 掌握度 ${snap.focus.masteryPct}%`})`);
+	lines.push(`焦点: ${snap.focus.courseTitle} [courseId ${snap.focus.courseId}] / ${snap.focus.lessonTitle} [lessonId ${snap.focus.lessonId}](${snap.focus.status}${snap.focus.masteryPct === null ? "" : `, 掌握度 ${snap.focus.masteryPct}%`})`);
 	if (snap.strategy !== null) lines.push(`教学策略: ${snap.strategy}`);
 	if (snap.concepts !== null && snap.concepts.length > 0) lines.push(`知识点(课级掌握度 = 最薄弱知识点): ${snap.concepts.map((c) => `${c.title} ${c.masteryPct}%${c.weak ? " ⚡薄弱" : ""}`).join(" · ")}`);
 	if (snap.friction.length > 0) lines.push(`近期卡点(共 ${snap.friction.length} 条): ${snap.friction.map((f) => `${f.category}${f.summary === null ? "" : `: ${f.summary}`}`).join(" / ")}`);
@@ -4799,10 +6571,11 @@ function createStudySurface(registry, store) {
 const name = "lookatstudy-plugin";
 const inject = ["tools", "systemPrompt"];
 /**
-* Register the activation-gated study surface: the 20 `study_*` tools (kept
-* unregistered while dormant), the tutor persona (stable core + soul), and
-* the dynamic learner-snapshot context — every prompt text renders empty
-* while inactive, and empty sections are dropped at assembly.
+* Register the activation-gated study surface: the 25 `study_*` tools (kept
+* unregistered while dormant), the tutor persona (stable core + soul), the
+* dynamic learner-snapshot context, and the `/study` command — every prompt
+* text renders empty while inactive, and empty sections are dropped at
+* assembly.
 * @param ctx - plugin context carrying the tool registry and system prompt.
 * @param config - validated plugin configuration.
 */
@@ -4834,12 +6607,20 @@ function apply(ctx, config) {
 		order: 50,
 		text: () => snapshotSectionText(store.get())
 	});
+	ctx.inject(["commands"], (cmdCtx) => {
+		const disposeCommand = registerStudyCommand(cmdCtx.commands, {
+			store,
+			onActiveChange: surface.sync
+		});
+		cmdCtx.effect(() => disposeCommand, "lookatstudy.studyCommand()");
+	});
 	ctx.inject(["webServer"], (webCtx) => {
 		const studyAreaPath = join(dirname(statePath), "study-area");
 		mkdirSync(studyAreaPath, { recursive: true });
 		const disposeDashboard = registerDashboard(webCtx.webServer, {
 			store,
 			studyAreaPath,
+			statePath,
 			onActiveChange: surface.sync
 		});
 		webCtx.effect(() => disposeDashboard, "lookatstudy.dashboard()");