dsh-plugin-lookatstudy 0.11.0 → 0.12.0

package/lib/index.mjs

@@ -1,11 +1,26 @@
+import { n as inflateZlib } from "./inflate-DIKUrTRi.mjs";
+import { t as extractArticle } from "./html-article-Da8ksU0i.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 { fileURLToPath } from "node:url";
 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 +54,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 +196,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 +298,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 +404,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 +477,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 +558,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 +765,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 +832,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 +843,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 +872,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 +881,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 +1168,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 +1192,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
 /**
@@ -995,6 +1321,20 @@ function tryFindLesson(state, lessonId) {
 * message channel were removed once the in-client study tab superseded them.
 * @module dsh-plugin-lookatstudy/dashboard
 */
+/** Wiring handed in by `apply`. */
+/**
+* The plugin's own version, read from the package.json sitting beside the
+* running module (src in dev, lib in install) — strictly the installed build,
+* no build-time inlining that could drift. Upstream v0.24.0 port (settings
+* About row); empty string on any read failure (display degrades, never throws).
+*/
+function pluginVersion() {
+	try {
+		return String(JSON.parse(readFileSync(fileURLToPath(new URL("../package.json", import.meta.url)), "utf8")).version ?? "");
+	} catch {
+		return "";
+	}
+}
 /**
 * Assemble the whole workbench state (pure read; the lesson HTML is rendered
 * server-side from the sanitized markdown pipeline).
@@ -1055,7 +1395,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 +1438,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 +1508,20 @@ 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,
+					version: pluginVersion()
+				});
+				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 +1641,187 @@ 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.cmap": "🕸 概念图",
+	"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.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.about": "关于",
+	"settings.about.hint": "当前运行的构建版本,点击查看该版更新内容。",
+	"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 +1829,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 +1837,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 +1932,8 @@ const EXT_KIND = {
 	htm: "html",
 	pdf: "pdf",
 	pptx: "pptx",
+	epub: "epub",
+	docx: "docx",
 	ipynb: "ipynb",
 	rst: "rst",
 	rmd: "rmd",
@@ -1555,7 +2105,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 +2170,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-B9IDkiGM.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 +2352,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-B9IDkiGM.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-oH96guBW.mjs");
+		return parseEpubFlat(buf);
+	}
 	if (kind === "ipynb") {
 		const raw = await readFile(absPath, "utf8");
 		const { parseNotebook } = await import("./notebook-parser-ChbZBIKJ.mjs");
@@ -1859,6 +2420,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 +2927,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 +3049,8 @@ function extractOutlineWithCharCounts(text, filePath) {
 	return {
 		h1: h1 || (filePath.split("/").pop() ?? filePath),
 		totalChars,
-		headings
+		headings,
+		bodyPreview: extractBodyPreview(text)
 	};
 }
 /**
@@ -2390,87 +3095,502 @@ async function fetchSingleFileContent(filePath, owner, repo, branch, fetchFn) {
 	}
 }
 /**
-* 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.
-* @param repo - repo name.
-* @param inventory - fetchRepoInventory output (README, file list, tree).
-* @param outlines - fetchFileOutlines output, keyed by path.
-* @returns the pending design the brief renders from.
+* 通用二进制下载(arXiv PDF 等):注入 fetchFn(跟随重定向),带取消与
+* 大小上限。fetchImageAsDataUrl 的泛化——那个只管 CDN 图片且吞错,这个要把
+* 失败原因如实抛给用户。
 */
-function buildPendingDesign(url, owner, repo, inventory, outlines) {
-	const files = [];
-	for (const discovered of inventory.fileList) {
-		const outline = outlines.get(discovered.path);
-		if (outline === void 0) continue;
-		files.push({
-			path: discovered.path,
-			role: discovered.kind === "ipynb" ? "practice" : "original",
-			outline
-		});
-	}
-	const courseTitle = inventory.readmeMd.match(/^#\s+(.+)$/m)?.[1]?.trim() || repo;
+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 {
-		source: "github",
-		url,
-		owner,
-		repo,
-		branch: inventory.branch,
-		courseTitle,
-		readmeExcerpt: inventory.readmeMd.slice(0, 4e3),
-		files,
-		fullTreeCount: inventory.fullTree.length
+		owner: m[1],
+		repo: m[2].replace(/\.git$/, "")
 	};
 }
+//#endregion
+//#region src/vendor/url-route.ts
 /**
-* Build the pending design from a local folder scan — the same brief, but the
-* bodies ride along (localContents), so apply is fully offline.
-* @param path - the absolute folder path (becomes sourceRef).
-* @param title - fallback course title (the folder's name).
-* @param docs - scanFolder output (relative paths + content).
-* @returns the pending design.
+* 智能 URL 路由 —— 一个输入框自动分流三类导入来源(纯函数)。
+*
+*   github.com/{owner}/{repo} → 走既有仓库导入(完整 5 步管线)
+*   arxiv.org / export.arxiv.org 的 /abs/ID 或 /pdf/ID → 论文 PDF 导入
+*   其余任意 http(s) → 网页文章正文抽取(readability)
+*
+* 用户不需要理解三种来源的区别。纯函数,verify 直测。
 */
-function buildPendingDesignFromFolder(path, title, docs) {
-	const files = docs.map((doc) => ({
-		path: doc.path,
-		role: doc.kind === "ipynb" ? "practice" : "original",
-		outline: extractOutlineWithCharCounts(doc.content, doc.path)
-	}));
-	const readme = docs.find((doc) => /^readme\.md$/i.test(doc.path.split("/").pop() ?? ""))?.content ?? "";
-	const courseTitle = readme.match(/^#\s+(.+)$/m)?.[1]?.trim() || title;
-	const localContents = new Map(docs.map((doc) => [doc.path, doc.content]));
+/** 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 {
-		source: "folder",
-		url: path,
-		owner: "",
-		repo: title,
-		branch: "local",
-		courseTitle,
-		readmeExcerpt: readme.slice(0, 4e3),
-		files,
-		fullTreeCount: docs.length,
-		localContents
+		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({
+	normalizeRadicals: () => normalizeRadicals,
+	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;
+}
 /**
-* Render the design brief — the ONLY channel into the tutor's context
-* (dsh models see tool results through output.render alone). Carries the
+* 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 normalizeRadicals(parts.join("\n").replace(/[ \t]+\n/g, "\n").replace(/\n{3,}/g, "\n\n").trim());
+}
+/**
+* 康熙部首区(U+2F00-U+2FDF)→CJK 统一表意区归一(upstream v0.23.1 port, verbatim)。
+* 部分中文 PDF 的 ToUnicode 映射落在部首区(d2l-zh 真书采样实测:"⼿⼀⽅"应读
+* "手一方"),部首区上检索/匹配全部断裂。逐字符 NFKC(部首→汉字是 Unicode 标准
+* 一对一兼容映射,不动其他任何字符)。
+*/
+function normalizeRadicals(md) {
+	if (!md) return md;
+	return /[\u2F00-\u2FDF]/.test(md) ? md.replace(/[\u2F00-\u2FDF]/g, (c) => c.normalize("NFKC")) : md;
+}
+//#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.
+* @param repo - repo name.
+* @param inventory - fetchRepoInventory output (README, file list, tree).
+* @param outlines - fetchFileOutlines output, keyed by path.
+* @returns the pending design the brief renders from.
+*/
+function buildPendingDesign(url, owner, repo, inventory, outlines) {
+	const files = [];
+	for (const discovered of inventory.fileList) {
+		const outline = outlines.get(discovered.path);
+		if (outline === void 0) continue;
+		files.push({
+			path: discovered.path,
+			role: discovered.kind === "ipynb" ? "practice" : "original",
+			outline
+		});
+	}
+	const courseTitle = inventory.readmeMd.match(/^#\s+(.+)$/m)?.[1]?.trim() || repo;
+	return {
+		source: "github",
+		url,
+		owner,
+		repo,
+		branch: inventory.branch,
+		courseTitle,
+		readmeExcerpt: inventory.readmeMd.slice(0, 4e3),
+		files,
+		fullTreeCount: inventory.fullTree.length
+	};
+}
+/**
+* Build the pending design from a local folder scan — the same brief, but the
+* bodies ride along (localContents), so apply is fully offline.
+* @param path - the absolute folder path (becomes sourceRef).
+* @param title - fallback course title (the folder's name).
+* @param docs - scanFolder output (relative paths + content).
+* @returns the pending design.
+*/
+function buildPendingDesignFromFolder(path, title, docs, extra) {
+	const files = docs.map((doc) => ({
+		path: doc.path,
+		role: doc.kind === "ipynb" ? "practice" : "original",
+		outline: extractOutlineWithCharCounts(doc.content, doc.path)
+	}));
+	const readme = docs.find((doc) => /^readme\.md$/i.test(doc.path.split("/").pop() ?? ""))?.content ?? "";
+	const courseTitle = readme.match(/^#\s+(.+)$/m)?.[1]?.trim() || title;
+	const localContents = new Map(docs.map((doc) => [doc.path, doc.content]));
+	return {
+		source: "folder",
+		url: path,
+		owner: "",
+		repo: title,
+		branch: "local",
+		courseTitle,
+		readmeExcerpt: readme.slice(0, 4e3),
+		files,
+		fullTreeCount: docs.length,
+		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() } : {}
+	};
+}
+/** 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 +3611,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 +3779,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 +3801,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 +3872,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 +3904,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 +4035,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 +4092,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 +4138,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 +4280,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,1167 +4303,1873 @@ 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
-						}
+			}
+		} },
+		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);
+			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"
+		}),
+		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",
+							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
+								},
+								mastered: {
+									type: "integer",
+									required: true
+								},
+								avgMasteryPct: {
+									...nullableInteger,
+									required: true
+								},
+								dueCount: {
+									type: "integer",
+									required: true
+								},
+								currentLessonId: {
+									...nullableString,
+									required: true
+								}
+							}
+						}
+					},
+					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
+							}
+						}
+					},
+					matches: {
+						type: "array",
+						description: "Full-text hits (present only when query was given).",
+						items: {
+							type: "object",
+							additionalProperties: false,
+							properties: {
+								courseId: {
+									type: "string",
+									required: true
+								},
+								courseTitle: {
+									type: "string",
+									required: true
+								},
+								lessonId: {
+									type: "string",
+									required: true
+								},
+								lessonTitle: {
+									type: "string",
+									required: true
+								},
+								snippet: {
+									type: "string",
+									required: true
+								}
+							}
+						}
+					}
 				}
-				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]);
+			},
+			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
+											}
+										}
+									}
+								}
+							}
+						}
 					}
-					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) => 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"
 		}),
-		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: {
+		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",
-							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: {
+									masteryPct: {
 										type: "integer",
 										required: true
 									},
-									avgMasteryPct: {
-										...nullableInteger,
+									weak: {
+										type: "boolean",
 										required: true
 									},
-									dueCount: {
+									/** 1 once this concept has been quizzed at least once, else 0 (ConceptView.tested). */
+									tested: {
 										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: {
+						}],
+						required: true
+					},
+					starters: {
+						type: "array",
+						required: true,
+						items: {
 							type: "object",
-							required: true,
 							additionalProperties: false,
 							properties: {
-								total: {
-									type: "integer",
+								label: {
+									type: "string",
 									required: true
 								},
-								mastered: {
-									type: "integer",
+								message: {
+									type: "string",
 									required: true
 								},
-								available: {
-									type: "integer",
-									required: true
+								effect: {
+									type: "string",
+									required: true,
+									enum: [
+										"mastery",
+										"friction",
+										"none"
+									]
 								}
 							}
-						},
-						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
-												}
-											}
-										}
-									}
+						}
+					},
+					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) => 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: {
+			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 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"
-										]
-									}
-								}
-							}
-						},
-						memory: {
+				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" }, {
 							type: "object",
-							required: true,
 							additionalProperties: false,
 							properties: {
-								lesson: {
-									...nullableString,
+								title: {
+									type: "string",
 									required: true
 								},
-								global: {
-									...nullableString,
+								masteryPct: {
+									type: "integer",
 									required: true
 								},
-								pattern: {
-									...nullableString,
+								weak: {
+									type: "boolean",
 									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
-						}
+						}],
+						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: `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."
+			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}`
+		}),
+		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
+					}
 				}
 			},
-			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
-									}
+			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
 								}
-							}],
-							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
-					};
-				});
+			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."
 			},
-			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)
-			})
+			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}`
 		}),
-		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) => [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 +6177,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
+						},
+						chars: {
+							type: "integer",
 							required: true
 						},
-						stored: {
+						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({
@@ -4664,41 +6464,43 @@ const TUTOR_CORE = `## Study tutor (lookatstudy-plugin)
 
 You are the learner's AI study tutor for a course imported via the study tools. Your job is genuine understanding, not reciting the material. When the learner answers wrong, acknowledge the attempt first, then correct it.
 
-### Grounding (hard rule)
+### 【Safety redlines · highest priority】
 Teach strictly from the current lesson's content (study_lesson's body is the source of truth). If asked about something outside the course material, say plainly that it is not in the current material, and offer to relate it back. Answers to quiz questions must be grounded in the lesson content — never invent.
+Tool calls are REAL or they do not exist. History markers like「[工具调用已执行]」are injected by the system only; hand-writing such a marker — or any imitation of a tool call — in your reply text produces NO interface artifact: no card, no button, nothing happens. The only way to act on the study state (record an answer, propose mastery, save a note) is an actual tool call. If you catch yourself narrating a tool's effect instead of calling it, stop and call it.
+Never claim progress you did not record through the tools.
+If any section below seems to conflict with these redlines, the redlines win.
 
-### Language
-Answer in the learner's own language (the language of their interface and their messages), including quiz stems, options, and explanations. Quote course material verbatim in its original language.
+### 【Teaching behavior】
+Language: answer in the learner's own language (the language of their interface and their messages), including quiz stems, options, and explanations. Quote course material verbatim in its original language.
 
-### Vague confusion
 When the learner says "我不懂 / 不太理解" without specifics, ask which concept is unclear, or list the lesson's 2–3 core concepts and let them pick. Log it silently with study_report_friction.
 
-### Interaction form
+Interaction form:
 - ONE question or interactive block per reply — never a wall of quiz questions.
-- Structure answers with markdown (headings, lists, GFM tables); for structures prefer visuals: concept maps and flow diagrams as mermaid code blocks, comparisons as GFM tables, code walkthroughs as fenced code with line-referenced annotations.
 - When the learner quotes text in「」, treat it as quote-to-explain: explain that specific passage in the lesson's context.
 - Opening a brand-new lesson: start with a short hook and one fun two-option guess (curiosity-driven, NOT scored, revealed next turn) — no opening lecture, no scored question.
 - After opening a lesson, offer its four starters (from study_lesson) as suggestions.
 - Celebrate graduations and crowns briefly — earned joy, no confetti spam.
 
-### The tutoring loop
+The tutoring loop:
 1. Session start: check study_due_reviews; clear due reviews before new material. Open the focus lesson with study_lesson. The learner follows along in the study tab's blackboard column — point them there when they want the course map or lesson text.
 2. First time teaching a lesson: derive 2–7 knowledge components and call study_define_concepts.
 3. Quiz after teaching; grade every answer and call study_record_answer — always name the tested \`concept\`. Lesson mastery is the WEAKEST concept, so target ⚡weak ones first.
 4. Progression is automatic: ≥50% mastery unlocks the next lesson early; ≥90% graduates and schedules the first review. study_complete_lesson is only the manual override.
 5. Mastery ≥85% plus a convincing Feynman-style explanation back: call study_propose_mastery, present your rationale, and WAIT for the learner's yes/no. Resolve only with their explicit answer via study_resolve_proposal. You never graduate a lesson on your own judgment alone.
-6. Quietly call study_report_friction when the learner seems confused, blocked, or frustrated; adapt by simplifying or decomposing.
-7. When you generate a genuinely useful structure (concept map, compare table, diagram), sediment it into the notebook's understand zone with study_note_save; when the learner writes something worth keeping, save it to the record zone with the verbatim quote.
-8. When you learn something durable about how this person learns (style, recurring gap, pattern), merge it into memory with study_remember — read the current slot first, send the merged 1–3 sentences. No transient chat.
+6. Exam nodes: when the learner works an exam, grade it fully, then record the attempt with study_exam_result and offer its returned action set (explain-wrong / retry / go-deeper / propose mastery / next topic).
+7. Quietly call study_report_friction when the learner seems confused, blocked, or frustrated; adapt by simplifying or decomposing.
+8. When you generate a genuinely useful structure (concept map, compare table, diagram), sediment it into the notebook's understand zone with study_note_save; when the learner writes something worth keeping, save it to the record zone with the verbatim quote.
+9. When you learn something durable about how this person learns (style, recurring gap, pattern), merge it into memory with study_remember — read the current slot first, send the merged 1–3 sentences. No transient chat.
+
+Never reveal the friction log or mastery mechanics as "being watched" — the numbers surface through maps and reviews.
 
-### Course import design
-When study_import_github or study_import_folder returns status "design_required", it renders a design brief (files with heading outlines and per-heading char counts). Design the course from it: classify lessons study/practice, let attached quiz/summary/review content ride along inside the previous study lesson's anchor range, pace lessons to 3000-8000 chars, merge sub-1000 fragments. Then call study_apply_design with the JSON — use ONLY file paths from the brief (anything else is dropped), apply directly without a confirmation round, and once it lands, walk the learner through the course map before the first lesson.
+Course import design: when study_import_github or study_import_folder returns status "design_required", it renders a design brief (files with heading outlines and per-heading char counts). Design the course from it: classify lessons study/practice, let attached quiz/summary/review content ride along inside the previous study lesson's anchor range, pace lessons to 3000-8000 chars, merge sub-1000 fragments. Then call study_apply_design with the JSON — use ONLY file paths from the brief (anything else is dropped), apply directly without a confirmation round, and once it lands, walk the learner through the course map before the first lesson.
 
-### Quiz quality
-3–4 questions per quiz block is best (5 max), 4 options each. Distractors must come from real misconceptions, not absurd fillers. Test understanding, not recall: "in scenario Y, use X or Z?" rather than "define X". Every question carries an explanation of why the right answer is right. One scored block at a time.
+Quiz quality: 3–4 questions per quiz block is best (5 max), 4 options each. Distractors must come from real misconceptions, not absurd fillers. Test understanding, not recall: "in scenario Y, use X or Z?" rather than "define X". Every question carries an explanation of why the right answer is right. One scored block at a time.
 
-### Integrity
-Never claim progress you did not record through the tools. Never reveal the friction log or mastery mechanics as "being watched" — the numbers surface through maps and reviews.
+### 【Answer formatting · preferences】
+Structure answers with markdown (headings, lists, GFM tables); for structures prefer visuals: concept maps and flow diagrams as mermaid code blocks, comparisons as GFM tables, code walkthroughs as fenced code with line-referenced annotations. These preferences are subordinate to the two sections above.
 `;
 /** The three builtin souls, verbatim from LookatStudy (direct/guide/practice). */
 const SOULS = {
@@ -4743,7 +6545,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 +6601,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 +6637,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()");