cotutor 0.2.0 → 0.4.0

package/dist/{lib → memory}/timetable.d.ts

@@ -10,12 +10,9 @@ export interface TimetableParse {
     errors: string[];
     found: boolean;
 }
-export declare function dayName(day: number): string;
 export declare function parseTimetable(md: string): TimetableParse;
 /** js Date → 1–7(周一–周日) */
 export declare function dayOf(now: Date): number;
-/** 本周(周一起算)第 day 天的日期 YYYY-MM-DD */
-export declare function weekDate(now: Date, day: number): string;
 /** 当前正在进行的时段(第一条命中;不在任何时段 = null,不猜) */
 export declare function currentSlot(entries: readonly TimetableEntry[], now: Date): TimetableEntry | null;
 /** 上下文包的 slot 字段:「数学 16:00-17:00」 */

package/dist/{lib → memory}/timetable.js

@@ -1,9 +1,5 @@
 const REQUIRED = ['星期', '时间', '学科'];
 const DAY_MAP = { 一: 1, 二: 2, 三: 3, 四: 4, 五: 5, 六: 6, 日: 7, 天: 7 };
-const DAY_NAMES = ['', '一', '二', '三', '四', '五', '六', '日'];
-export function dayName(day) {
-    return `周${DAY_NAMES[day] ?? '?'}`;
-}
 const cells = (line) => line
     .replace(/^\s*\|/, '')
     .replace(/\|\s*$/, '')
@@ -87,13 +83,6 @@ export function dayOf(now) {
     const d = now.getDay();
     return d === 0 ? 7 : d;
 }
-/** 本周(周一起算)第 day 天的日期 YYYY-MM-DD */
-export function weekDate(now, day) {
-    const d = new Date(now);
-    d.setDate(d.getDate() + (day - dayOf(now)));
-    const p = (n) => String(n).padStart(2, '0');
-    return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
-}
 /** 当前正在进行的时段(第一条命中;不在任何时段 = null,不猜) */
 export function currentSlot(entries, now) {
     const day = dayOf(now);

package/dist/memory/vault-notes.d.ts

@@ -0,0 +1,165 @@
+/**
+ * vault 里家长写的笔记按 frontmatter 定位(《obsidian仓库设计.md》):
+ * `cotutor: profile | subject | textbook`,不认文件名与目录——家长会改名、挪位置。
+ *  - profile:孩子档案,一个 vault 一个;`school_start: YYYY-MM` 算当前学期,`semester` 可覆盖
+ *  - subject:一科一学期一个,就是这位老师的**入口文件**,原文整篇进上下文包
+ *  - textbook:可以没有、可以多本;只给路径,老师要用自己 Read
+ *  - memory:一个 agent 一篇(`agent: <name>`),老师在回复里写「## 记忆」、应用追加;家长可读可改,原文整篇进上下文包。
+ *    `agent: all` 那篇是孩子的记忆(2026-10-30):关于孩子本人、换一科也成立的,所有有脸的老师共用,老师写 `孩子:` 开头的行进这里
+ * 程序读的键用英文(cotutor / subject / semester / school_start / agent),中文键是给人看的描述,这里不读。
+ */
+import type { MemoryLine } from '../schema/index.ts';
+export declare const NOTE_KINDS: readonly ["profile", "subject", "textbook", "memory"];
+export type NoteKind = (typeof NOTE_KINDS)[number];
+export interface VaultNote {
+    /** 相对 vault 根,`/` 分隔 */
+    path: string;
+    props: Record<string, string>;
+    /** 整篇原文(含 frontmatter) */
+    text: string;
+}
+/** 只认平铺的 `key: value`;值去掉成对引号。没有 frontmatter → {} */
+export declare function frontmatter(md: string): Record<string, string>;
+/**
+ * 某天是几年级的哪个学期 / 假期:9–1 月上学期、2 月寒假、3–6 月下学期、7–8 月暑假(刚读完的那个年级的暑假)。
+ * 学年从 9 月算;`school_start` 是读一年级那年的 9 月(写别的月份也按它所在学年算)。年级不在 1–12 → null。
+ */
+export declare function semesterAt(schoolStart: string, date: string): string | null;
+/** 正文里的 `[[目标]]` / `![[目标|别名]]`:去掉 #节 与 |别名,去重,按出现顺序 */
+export declare function wikilinks(md: string): string[];
+/** 像 Obsidian 那样解析链接:先按相对根的完整路径(可省 .md),再按文件名(同名取路径最短的);找不到 → null */
+export declare function resolveLink(target: string, files: readonly string[]): string | null;
+export interface VaultPick {
+    profile: VaultNote | null;
+    /** 不止一个 `cotutor: profile` 时的其余几个(用写了 school_start / semester 的、再按路径的第一篇,doctor 报) */
+    extraProfiles: string[];
+    /** 当前学期;档案没有、没写 school_start 也没写 semester、或年级算不出 → null */
+    semester: string | null;
+    /** 这科这学期的入口文件;没有 → null(不沿用上学期的) */
+    entry: VaultNote | null;
+    /** 同一科同一学期不止一个入口文件时的其余几个 */
+    extraEntries: string[];
+    /** 这位 agent 的记忆文件;还没有 → null */
+    memory: VaultNote | null;
+    extraMemories: string[];
+    /** 孩子的记忆(`agent: all`);还没有 → null */
+    child: VaultNote | null;
+    /** 参考资料的路径:这科这学期的教材 + 档案与入口文件里的 [[链接]](去重,不含它俩自己) */
+    refs: string[];
+    /** 这科这学期的教材(取材用,memory/retrieval.ts) */
+    textbooks: VaultNote[];
+}
+/**
+ * 从扫出来的笔记里挑一位老师要的:档案、当前学期、入口文件、参考路径。
+ * `files` 是 vault 里所有文件的相对路径(解析 [[链接]] 用,不限 .md)。subject 没配 → 没有入口文件。
+ */
+export declare function pickNotes(notes: readonly VaultNote[], files: readonly string[], opts: {
+    date: string;
+    subject?: string;
+    agent?: string;
+}): VaultPick;
+/** 入口文件缺了为什么(进上下文包 entry: 与这条消息的 warnings;家长端就看得到) */
+export declare function missingEntry(subject: string | undefined, pick: {
+    profile: unknown;
+    semester: string | null;
+}): string;
+/** 记忆文件缺省位置:记忆/<显示名>.md(显示名里的 / 换掉) */
+export declare function memoryPath(display: string): string;
+/** 新建的记忆文件 */
+export declare function memoryTemplate(agent: string, display: string): string;
+/** 孩子的记忆(2026-10-30):`agent: all` 的那篇,缺省在 记忆/孩子.md;满了(列表行到 CHILD_MEMORY_CAP 条)新的不再进,提醒家长删 */
+export declare const CHILD_MEMORY_AGENT = "all";
+export declare const CHILD_MEMORY_PATH = "\u8BB0\u5FC6/\u5B69\u5B50.md";
+export declare const CHILD_MEMORY_CAP = 20;
+/** 新建的孩子的记忆 */
+export declare function childMemoryTemplate(): string;
+/**
+ * 往记忆文件末尾追加:每条一行 `- <日期> <原话>`(老师自己写了日期开头就不再加);文里已有同样的话就跳过。
+ * cap:列表行最多这么多条,满了的不加,进 full。返回新全文与真加上的行;一条都没加 → text 原样。
+ */
+export declare function appendMemory(existing: string, items: readonly string[], date: string, cap?: number): {
+    text: string;
+    added: string[];
+    full: string[];
+};
+/**
+ * 「## 记忆」段的一条(2026-09-18):缺省是新增;`改:原话 → 新的` 改一行;`删:原话` 删一行。
+ * 冒号全角半角都认,箭头认 → 与 ->。原话或新的里也有箭头(「宇宙→太空员」、骨架「数一数 → 分一分」)时切法不止一种:
+ * from / to 是从第一个箭头切的,alt 是其余箭头的切法(从左到右),applyMemoryOps 挑原话对得上的那种(2026-10-31)。
+ */
+export type MemoryOp = {
+    op: 'add';
+    text: string;
+} | {
+    op: 'change';
+    from: string;
+    to: string;
+    alt?: {
+        from: string;
+        to: string;
+    }[];
+} | {
+    op: 'delete';
+    from: string;
+};
+export declare function parseMemoryOp(item: string): MemoryOp;
+/** 一行改动给家长看的样子:新增的原话、「改:旧 → 新」、「删:旧」(家长端「记录」的「记住了」) */
+export declare function memoryLineText(l: MemoryLine): string;
+/**
+ * 按原话找一行:正文(frontmatter 之后)里原话一字不差的那行;没有就找唯一一行包含它的(原话至少 4 个字);都不是 → -1。
+ * 不分老师写的、家长写的(2026-09-18 定:机器一律可以改)。fuzzy = false 只认一字不差的(这轮里家长改过文件,2026-10-30)。
+ */
+export declare function findMemoryLine(lines: readonly string[], from: string, bodyStart: number, fuzzy?: boolean): number;
+export interface MemoryApplied {
+    text: string;
+    /** 给家长看的改动,一条一行:新增的原样(`- <日期> …`),改的「改:旧 → 新」,删的「删:旧」 */
+    changes: string[];
+    /** 找不到原话的改 / 删 */
+    misses: string[];
+    /** 满了没加上的新增(有 cap 时) */
+    full: string[];
+    /** 同一批改动的整行原文:before = 改之前那行(新增为 null),after = 改之后那行(删掉为 null);删话题时 undoMemoryLines 按它撤销 */
+    lines: MemoryLine[];
+}
+export type { MemoryLine };
+/**
+ * 把一串操作落到记忆全文上:先改、删(按原话找行,见 findMemoryLine),再把新增的追加到末尾(appendMemory,去重)。
+ * 改过的列表行换成 `- <今天> 新的`(新的自己带着日期就去掉,不写两个日期);不是列表的行整行换成新的。strict:改、删只认一字不差的原话;cap:新增后最多几条(先删后加,删掉的腾出地方)。
+ * 改有几种切法(parseMemoryOp 的 alt)时:先挑原话一字不差的那种;都不是再模糊找,原话长的先(短的是长的前缀,会把原话后半截切进新的里)。
+ */
+export declare function applyMemoryOps(existing: string, ops: readonly MemoryOp[], date: string, opts?: {
+    strict?: boolean;
+    cap?: number;
+}): MemoryApplied;
+/**
+ * 撤销一串改动(删话题时,2026-10-05):倒着来——改了的换回原来那行,新增的删掉,删了的接回末尾(原来的位置不记)。
+ * 按整行原文找;家长或整理那轮后来又改过那行就找不到,进 misses,不动。
+ */
+export declare function undoMemoryLines(existing: string, edits: readonly MemoryLine[]): {
+    text: string;
+    undone: number;
+    misses: string[];
+};
+/** 记忆文件里有几条(frontmatter 之后的列表行) */
+export declare function memoryCount(text: string): number;
+/**
+ * 记账后整理记忆那轮的消息正文(2026-09-18):新会话、from: system;记忆原文在上下文包的 <vault-note role="memory">。
+ * 回的「## 记忆」段不受每轮条数上限,应用照单落盘、不问家长(家长在 Obsidian 里兜底)。
+ */
+export declare function tidyMemoryPrompt(opts: {
+    date: string;
+    count: number;
+    cap: number;
+    diaryFile: string;
+}): string;
+/**
+ * 按 entryChars 截一篇笔记带进上下文包。档案、入口文件留开头(家长写在前面的最要紧);
+ * 记忆留末尾——应用往末尾追加,最新的在后面,截开头丢的是旧的(2026-09-18 之前留的是开头,越记越看不到新的)。
+ * 末尾那头从一行的开头起,不截半行。
+ */
+export declare function clipNote(text: string, limit: number, keep: 'head' | 'tail'): {
+    text: string;
+    cut: boolean;
+};
+/** 短 hash(FNV-1a 32 位):同一话题里判断「这篇上次带过、没改」 */
+export declare function textHash(s: string): string;

package/dist/memory/vault-notes.js

@@ -0,0 +1,359 @@
+/**
+ * vault 里家长写的笔记按 frontmatter 定位(《obsidian仓库设计.md》):
+ * `cotutor: profile | subject | textbook`,不认文件名与目录——家长会改名、挪位置。
+ *  - profile:孩子档案,一个 vault 一个;`school_start: YYYY-MM` 算当前学期,`semester` 可覆盖
+ *  - subject:一科一学期一个,就是这位老师的**入口文件**,原文整篇进上下文包
+ *  - textbook:可以没有、可以多本;只给路径,老师要用自己 Read
+ *  - memory:一个 agent 一篇(`agent: <name>`),老师在回复里写「## 记忆」、应用追加;家长可读可改,原文整篇进上下文包。
+ *    `agent: all` 那篇是孩子的记忆(2026-10-30):关于孩子本人、换一科也成立的,所有有脸的老师共用,老师写 `孩子:` 开头的行进这里
+ * 程序读的键用英文(cotutor / subject / semester / school_start / agent),中文键是给人看的描述,这里不读。
+ */
+export const NOTE_KINDS = ['profile', 'subject', 'textbook', 'memory'];
+/** 只认平铺的 `key: value`;值去掉成对引号。没有 frontmatter → {} */
+export function frontmatter(md) {
+    const lines = md.replace(/^\uFEFF/, '').split(/\r?\n/);
+    if (lines[0]?.trim() !== '---')
+        return {};
+    const out = {};
+    for (let i = 1; i < lines.length; i++) {
+        const l = lines[i];
+        if (l.trim() === '---')
+            return out;
+        const m = /^([^\s:#][^:]*?)\s*:\s*(.*)$/.exec(l);
+        if (!m)
+            continue;
+        let v = m[2].trim();
+        if (v.length >= 2 && ((v[0] === '"' && v.at(-1) === '"') || (v[0] === "'" && v.at(-1) === "'")))
+            v = v.slice(1, -1);
+        out[m[1]] = v;
+    }
+    return {};
+}
+const CN_DIGITS = ['', '一', '二', '三', '四', '五', '六', '七', '八', '九', '十', '十一', '十二'];
+/**
+ * 某天是几年级的哪个学期 / 假期:9–1 月上学期、2 月寒假、3–6 月下学期、7–8 月暑假(刚读完的那个年级的暑假)。
+ * 学年从 9 月算;`school_start` 是读一年级那年的 9 月(写别的月份也按它所在学年算)。年级不在 1–12 → null。
+ */
+export function semesterAt(schoolStart, date) {
+    const s = /^(\d{4})-(\d{1,2})$/.exec(schoolStart.trim());
+    const d = /^(\d{4})-(\d{2})-\d{2}/.exec(date);
+    if (!s || !d)
+        return null;
+    const sm = Number(s[2]);
+    if (sm < 1 || sm > 12)
+        return null;
+    const startYear = sm >= 9 ? Number(s[1]) : Number(s[1]) - 1;
+    const y = Number(d[1]);
+    const m = Number(d[2]);
+    const schoolYear = m >= 9 ? y : y - 1;
+    const grade = schoolYear - startYear + 1;
+    if (grade < 1 || grade >= CN_DIGITS.length)
+        return null;
+    const term = m >= 9 || m === 1 ? '上' : m === 2 ? '寒假' : m <= 6 ? '下' : '暑假';
+    return `${CN_DIGITS[grade]}年级${term}`;
+}
+/** 正文里的 `[[目标]]` / `![[目标|别名]]`:去掉 #节 与 |别名,去重,按出现顺序 */
+export function wikilinks(md) {
+    const out = [];
+    for (const m of md.matchAll(/!?\[\[([^\]|#]*)(?:#[^\]|]*)?(?:\|[^\]]*)?\]\]/g)) {
+        const t = m[1].trim();
+        if (t && !out.includes(t))
+            out.push(t);
+    }
+    return out;
+}
+/** 像 Obsidian 那样解析链接:先按相对根的完整路径(可省 .md),再按文件名(同名取路径最短的);找不到 → null */
+export function resolveLink(target, files) {
+    const t = target.replace(/^\/+/, '');
+    const exact = files.find((f) => f === t || f === `${t}.md`);
+    if (exact)
+        return exact;
+    const base = t.includes('/') ? null : t;
+    if (!base)
+        return null;
+    const hits = files.filter((f) => {
+        const name = f.slice(f.lastIndexOf('/') + 1);
+        return name === base || name === `${base}.md`;
+    });
+    return hits.sort((a, b) => a.length - b.length || a.localeCompare(b))[0] ?? null;
+}
+const byPath = (a, b) => a.path.localeCompare(b.path);
+/**
+ * 从扫出来的笔记里挑一位老师要的:档案、当前学期、入口文件、参考路径。
+ * `files` 是 vault 里所有文件的相对路径(解析 [[链接]] 用,不限 .md)。subject 没配 → 没有入口文件。
+ */
+export function pickNotes(notes, files, opts) {
+    const of = (k) => notes.filter((n) => n.props.cotutor === k).sort(byPath);
+    // 不止一篇时先要写了学期信息的那篇
+    const dated = (n) => (n.props.semester?.trim() || n.props.school_start?.trim() ? 0 : 1);
+    const profiles = of('profile').sort((a, b) => dated(a) - dated(b));
+    const profile = profiles[0] ?? null;
+    const semester = profile ? (profile.props.semester?.trim() || (profile.props.school_start ? semesterAt(profile.props.school_start, opts.date) : null)) : null;
+    const same = (n) => !!opts.subject && !!semester && n.props.subject?.trim() === opts.subject && n.props.semester?.trim() === semester;
+    const entries = of('subject').filter(same);
+    const entry = entries[0] ?? null;
+    const memories = of('memory').filter((n) => !!opts.agent && n.props.agent?.trim() === opts.agent);
+    const child = of('memory').find((n) => n.props.agent?.trim() === CHILD_MEMORY_AGENT) ?? null;
+    const textbooks = of('textbook').filter(same);
+    const refs = textbooks.map((n) => n.path);
+    for (const n of [profile, entry]) {
+        if (!n)
+            continue;
+        for (const l of wikilinks(n.text)) {
+            const p = resolveLink(l, files);
+            if (p)
+                refs.push(p);
+        }
+    }
+    const self = new Set([profile?.path, entry?.path]);
+    return {
+        profile,
+        extraProfiles: profiles.slice(1).map((n) => n.path),
+        semester,
+        entry,
+        extraEntries: entries.slice(1).map((n) => n.path),
+        memory: memories[0] ?? null,
+        extraMemories: memories.slice(1).map((n) => n.path),
+        child,
+        refs: [...new Set(refs)].filter((p) => !self.has(p)),
+        textbooks,
+    };
+}
+/** 入口文件缺了为什么(进上下文包 entry: 与这条消息的 warnings;家长端就看得到) */
+export function missingEntry(subject, pick) {
+    if (!subject)
+        return '缺:cotutor.json 里这位老师没配 subject';
+    if (!pick.profile)
+        return '缺:vault 里没有 cotutor: profile 的档案,算不出学期';
+    if (!pick.semester)
+        return '缺:档案没写 school_start(或 semester),算不出学期';
+    return `缺:vault 里没有 cotutor: subject、subject: ${subject}、semester: ${pick.semester} 的文件`;
+}
+/** 记忆文件缺省位置:记忆/<显示名>.md(显示名里的 / 换掉) */
+export function memoryPath(display) {
+    return `记忆/${display.replace(/[\\/:]/g, '-')}.md`;
+}
+/** 新建的记忆文件 */
+export function memoryTemplate(agent, display) {
+    return `---
+cotutor: memory
+agent: ${agent}
+---
+
+${display}自己记下的,每个话题开头会整篇读到。你可以随便改、删、分小节;新的加在末尾,老师也会改、删这里的任何一行(记账后整理一次)。
+
+`;
+}
+/** 孩子的记忆(2026-10-30):`agent: all` 的那篇,缺省在 记忆/孩子.md;满了(列表行到 CHILD_MEMORY_CAP 条)新的不再进,提醒家长删 */
+export const CHILD_MEMORY_AGENT = 'all';
+export const CHILD_MEMORY_PATH = '记忆/孩子.md';
+export const CHILD_MEMORY_CAP = 20;
+/** 新建的孩子的记忆 */
+export function childMemoryTemplate() {
+    return `---
+cotutor: memory
+agent: ${CHILD_MEMORY_AGENT}
+---
+
+关于孩子本人、换一科也成立的事(情绪、读写、注意力、家里谁在旁边),每位老师每个话题开头都会读到。老师在「## 记忆」里写「孩子:」开头的行,应用记在这里;你可以随便改、删。和档案说的不一样时,以档案为准。最多 ${CHILD_MEMORY_CAP} 条,满了就不再记,删几条才有地方。
+
+`;
+}
+/**
+ * 往记忆文件末尾追加:每条一行 `- <日期> <原话>`(老师自己写了日期开头就不再加);文里已有同样的话就跳过。
+ * cap:列表行最多这么多条,满了的不加,进 full。返回新全文与真加上的行;一条都没加 → text 原样。
+ */
+export function appendMemory(existing, items, date, cap) {
+    const has = (s) => existing.split('\n').some((l) => l.replace(/^\s*[-*]\s+(\d{4}-\d{2}-\d{2}\s+)?/, '').trim() === s);
+    const added = [];
+    const full = [];
+    const room = cap === undefined ? Infinity : cap - memoryCount(existing);
+    for (const raw of items) {
+        const s = raw.replace(/\s+/g, ' ').trim();
+        const bare = s.replace(/^\d{4}-\d{2}-\d{2}\s+/, '');
+        if (!bare || has(bare) || added.some((a) => a.endsWith(` ${bare}`)))
+            continue;
+        if (added.length >= room) {
+            full.push(bare);
+            continue;
+        }
+        added.push(`- ${/^\d{4}-\d{2}-\d{2}\s/.test(s) ? s : `${date} ${s}`}`);
+    }
+    if (!added.length)
+        return { text: existing, added, full };
+    const base = existing.replace(/\s*$/, '');
+    return { text: `${base}\n${/^\s*[-*]\s/.test(base.split('\n').at(-1) ?? '') ? '' : '\n'}${added.join('\n')}\n`, added, full };
+}
+export function parseMemoryOp(item) {
+    const s = item.replace(/\s+/g, ' ').trim();
+    const del = /^删[:：]\s*(.+)$/.exec(s);
+    if (del)
+        return { op: 'delete', from: del[1].trim() };
+    const body = /^改[:：]\s*(.+)$/.exec(s)?.[1] ?? '';
+    const cuts = [...body.matchAll(/\s*(?:→|->)\s*/g)].map((m) => ({ from: body.slice(0, m.index).trim(), to: body.slice(m.index + m[0].length).trim() })).filter((c) => c.from && c.to);
+    if (cuts.length)
+        return { op: 'change', ...cuts[0], ...(cuts.length > 1 ? { alt: cuts.slice(1) } : {}) };
+    return { op: 'add', text: s };
+}
+/** 一行记忆去掉列表点与日期前缀后的原话(比对用) */
+const bareLine = (l) => l.replace(/^\s*[-*]\s+/, '').replace(/^\d{4}-\d{2}-\d{2}\s+/, '').replace(/\s+/g, ' ').trim();
+/** 一行改动给家长看的样子:新增的原话、「改:旧 → 新」、「删:旧」(家长端「记录」的「记住了」) */
+export function memoryLineText(l) {
+    if (l.before === null)
+        return bareLine(l.after ?? '');
+    if (l.after === null)
+        return `删:${bareLine(l.before)}`;
+    return `改:${bareLine(l.before)} → ${bareLine(l.after)}`;
+}
+/**
+ * 按原话找一行:正文(frontmatter 之后)里原话一字不差的那行;没有就找唯一一行包含它的(原话至少 4 个字);都不是 → -1。
+ * 不分老师写的、家长写的(2026-09-18 定:机器一律可以改)。fuzzy = false 只认一字不差的(这轮里家长改过文件,2026-10-30)。
+ */
+export function findMemoryLine(lines, from, bodyStart, fuzzy = true) {
+    const want = bareLine(from);
+    if (!want)
+        return -1;
+    const exact = lines.findIndex((l, i) => i >= bodyStart && bareLine(l) === want);
+    if (exact >= 0)
+        return exact;
+    if (!fuzzy || Array.from(want).length < 4)
+        return -1;
+    const hits = lines.map((l, i) => (i >= bodyStart && l.trim() && bareLine(l).includes(want) ? i : -1)).filter((i) => i >= 0);
+    return hits.length === 1 ? hits[0] : -1;
+}
+/**
+ * 把一串操作落到记忆全文上:先改、删(按原话找行,见 findMemoryLine),再把新增的追加到末尾(appendMemory,去重)。
+ * 改过的列表行换成 `- <今天> 新的`(新的自己带着日期就去掉,不写两个日期);不是列表的行整行换成新的。strict:改、删只认一字不差的原话;cap:新增后最多几条(先删后加,删掉的腾出地方)。
+ * 改有几种切法(parseMemoryOp 的 alt)时:先挑原话一字不差的那种;都不是再模糊找,原话长的先(短的是长的前缀,会把原话后半截切进新的里)。
+ */
+export function applyMemoryOps(existing, ops, date, opts = {}) {
+    const lines = existing.split('\n');
+    const fm = /^\uFEFF?---\s*$/.test(lines[0] ?? '') ? lines.findIndex((l, i) => i > 0 && /^---\s*$/.test(l)) : -1;
+    const bodyStart = fm > 0 ? fm + 1 : 0;
+    const changes = [];
+    const misses = [];
+    const edits = [];
+    const gone = new Set();
+    const locate = (o) => {
+        const cuts = o.op === 'change' ? [{ from: o.from, to: o.to }, ...(o.alt ?? [])] : [{ from: o.from, to: '' }];
+        const free = (i) => i >= 0 && !gone.has(i);
+        for (const c of cuts) {
+            const i = findMemoryLine(lines, c.from, bodyStart, false);
+            if (free(i))
+                return { i, to: c.to };
+        }
+        if (!opts.strict)
+            for (const c of [...cuts].reverse()) {
+                const i = findMemoryLine(lines, c.from, bodyStart, true);
+                if (free(i))
+                    return { i, to: c.to };
+            }
+        return { i: -1, to: '' };
+    };
+    for (const o of ops) {
+        if (o.op === 'add')
+            continue;
+        const { i, to } = locate(o);
+        if (i < 0) {
+            misses.push(o.op === 'change' ? `改:${o.from}` : `删:${o.from}`);
+            continue;
+        }
+        const old = bareLine(lines[i]);
+        if (o.op === 'delete') {
+            gone.add(i);
+            changes.push(`删:${old}`);
+            edits.push({ before: lines[i], after: null });
+        }
+        else {
+            const bullet = /^(\s*[-*]\s+)/.exec(lines[i]);
+            const before = lines[i];
+            const fresh = to.replace(/^\d{4}-\d{2}-\d{2}\s+/, '');
+            lines[i] = bullet ? `${bullet[1]}${date} ${fresh}` : fresh;
+            changes.push(`改:${old} → ${fresh}`);
+            edits.push({ before, after: lines[i] });
+        }
+    }
+    const kept = lines.filter((_, i) => !gone.has(i)).join('\n');
+    const adds = ops.flatMap((o) => (o.op === 'add' ? [o.text] : []));
+    const r = appendMemory(kept, adds, date, opts.cap);
+    return { text: r.text, changes: [...changes, ...r.added], misses, full: r.full, lines: [...edits, ...r.added.map((after) => ({ before: null, after }))] };
+}
+/**
+ * 撤销一串改动(删话题时,2026-10-05):倒着来——改了的换回原来那行,新增的删掉,删了的接回末尾(原来的位置不记)。
+ * 按整行原文找;家长或整理那轮后来又改过那行就找不到,进 misses,不动。
+ */
+export function undoMemoryLines(existing, edits) {
+    let lines = existing.split('\n');
+    let undone = 0;
+    const misses = [];
+    const back = [];
+    for (const e of [...edits].reverse()) {
+        if (e.after === null) {
+            if (e.before !== null) {
+                back.unshift(e.before);
+                undone++;
+            }
+            continue;
+        }
+        const i = lines.findIndex((l) => l === e.after);
+        if (i < 0) {
+            misses.push(bareLine(e.after));
+            continue;
+        }
+        lines = e.before === null ? lines.filter((_, k) => k !== i) : lines.map((l, k) => (k === i ? e.before : l));
+        undone++;
+    }
+    let text = lines.join('\n');
+    if (back.length) {
+        const base = text.replace(/\s*$/, '');
+        text = `${base}\n${/^\s*[-*]\s/.test(base.split('\n').at(-1) ?? '') ? '' : '\n'}${back.join('\n')}\n`;
+    }
+    return { text, undone, misses };
+}
+/** 记忆文件里有几条(frontmatter 之后的列表行) */
+export function memoryCount(text) {
+    const body = text.replace(/^\uFEFF?---\s*\n[\s\S]*?\n---\s*(\n|$)/, '');
+    return body.split('\n').filter((l) => /^\s*[-*]\s+\S/.test(l)).length;
+}
+/**
+ * 记账后整理记忆那轮的消息正文(2026-09-18):新会话、from: system;记忆原文在上下文包的 <vault-note role="memory">。
+ * 回的「## 记忆」段不受每轮条数上限,应用照单落盘、不问家长(家长在 Obsidian 里兜底)。
+ */
+export function tidyMemoryPrompt(opts) {
+    return [
+        `学习结束、账记完了,把你的记忆整理一遍。记忆文件的原文在上下文包的 <vault-note role="memory">(现在 ${opts.count} 条;截了就自己 Read 全文),今天(${opts.date})的日记在 ${opts.diaryFile},读你这一科的几段对照一下。`,
+        '',
+        '只回一段「## 记忆」,一行一条,别的一个字都不用写:',
+        '',
+        '## 记忆',
+        '- 删:原话(过时的、今天看出来不对的、和别的重复的)',
+        '- 改:原话 → 新的(要更新的,比如「还没学竖式 → 9 月中学会了两位数竖式」;几条说一件事就改成一条、删掉其余)',
+        '- 新的一条(今天日记里看出来、以后还用得上、记忆里还没有的)',
+        '',
+        `原话照记忆文件里那一行抄,日期可以不抄;谁写的行都可以改、删。整理完不超过 ${opts.cap} 条。都不用动就只回一句「记忆不用整理」,不写「## 记忆」段。`,
+    ].join('\n');
+}
+/**
+ * 按 entryChars 截一篇笔记带进上下文包。档案、入口文件留开头(家长写在前面的最要紧);
+ * 记忆留末尾——应用往末尾追加,最新的在后面,截开头丢的是旧的(2026-09-18 之前留的是开头,越记越看不到新的)。
+ * 末尾那头从一行的开头起,不截半行。
+ */
+export function clipNote(text, limit, keep) {
+    if (text.length <= limit)
+        return { text, cut: false };
+    if (keep === 'head')
+        return { text: `${text.slice(0, limit)}\n……(后面截掉了,要看全文自己 Read)`, cut: true };
+    const tail = text.slice(-limit);
+    const nl = tail.indexOf('\n');
+    const aligned = text.at(-limit - 1) === '\n' || nl < 0 ? tail : tail.slice(nl + 1);
+    return { text: `……(前面旧的截掉了,下面是最近的;要看全文自己 Read)\n${aligned}`, cut: true };
+}
+/** 短 hash(FNV-1a 32 位):同一话题里判断「这篇上次带过、没改」 */
+export function textHash(s) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < s.length; i++) {
+        h ^= s.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+    return (h >>> 0).toString(16).padStart(8, '0');
+}

package/dist/memory/vault.d.ts

@@ -0,0 +1,70 @@
+import { type MemoryLine, type VaultNote } from './vault-notes.ts';
+import type { ConversationMessage, PathRole } from '../schema/index.ts';
+/** vault 在哪:workspace 的 paths(vault、diary、plans、textbooks…);传整个 workspace 也行 */
+export interface Vault {
+    paths: Readonly<Record<PathRole, string>>;
+}
+/** 删话题撤销了多少:记忆几行、日记几段;找不到原文没撤的(家长或整理那轮后来改过)一条一句 */
+export interface ThreadUndo {
+    memory: number;
+    diary: number;
+    misses: string[];
+}
+/**
+ * 删话题时撤回它留在 vault 里的:各轮写进记忆的行(memoryLines;孩子的记忆是 childLines)倒着撤、记账写进日记的那段(diaryBlock)摘掉;
+ * 找不到原文的(家长或整理那轮后来改过)不撤,一条一句列进 misses
+ */
+export declare function undoThreadVault(v: Vault, tutor: string, date: string, gone: readonly ConversationMessage[]): Promise<ThreadUndo>;
+/** 这几天的日记(<日记目录>/<日期>.md);没有的跳过 */
+export declare function readDiaries(v: Vault, dates: readonly string[]): Promise<{
+    date: string;
+    text: string;
+}[]>;
+/** 当天的日记:update 拿现有内容(没有 → null)回新内容;先 .tmp 再 rename。返回文件名(<日期>.md) */
+export declare function writeDiary(v: Vault, date: string, update: (existing: string | null) => string): Promise<string>;
+/** 教材目录下的每册文件(<教材目录>/<册>.md),给 textbookHeadings;没有目录 → [] */
+export declare function readTextbooks(v: Vault): Promise<{
+    name: string;
+    text: string;
+}[]>;
+/**
+ * 扫 vault:所有文件的相对路径(解析 [[链接]] 用)+ 带 `cotutor:` 属性的 md(按属性定位,《obsidian仓库设计.md》2026-09-17)。
+ * 跳过点开头的目录(.obsidian / .git)与日记、计划目录(机器写的,不带属性,越积越多)。读不到的文件跳过;vault 不在 → 全空。
+ */
+export declare function scanVault(v: Vault): Promise<{
+    notes: VaultNote[];
+    files: string[];
+}>;
+/** 要写进记忆文件的一次改动(还没写):planVaultMemory 算,writeVaultMemory 写 */
+export interface MemoryPlan {
+    /** 相对 vault 根 */
+    file: string;
+    /** 算的时候文件的原文;新建 = null */
+    base: string | null;
+    text: string;
+    changes: string[];
+    lines: MemoryLine[];
+}
+/**
+ * 「## 记忆」段 → 这位 agent 的记忆文件要怎么改(按 `cotutor: memory` + `agent:` 找;没有就建 记忆/<显示名>.md,孩子的记忆建 记忆/孩子.md),只算不写:
+ * 新增追加到末尾,「改:」「删:」按原话找行改、删(任何一行都能动,2026-09-18);缺省位置已有一篇没属性的同名文件就不碰,进提醒。
+ * seen = 这一轮上下文包里老师看到的那版(截过的那段的 textHash 与截的字数):文件和它对不上 = 这轮里家长改过,
+ * 改、删只认一字不差的原话,找不到的不改——按「包含」找会把家长刚补上的半句一起盖掉(2026-10-30)。
+ * 孩子的记忆(agent: all)最多 CHILD_MEMORY_CAP 条,满了新增的不进,提醒家长删几条。
+ */
+export declare function planVaultMemory(v: Vault, o: {
+    agent: string;
+    display: string;
+    items: readonly string[];
+    date: string;
+    seen?: {
+        path: string;
+        hash: string;
+        clip: number;
+    };
+}): Promise<{
+    plan: MemoryPlan | null;
+    warnings: string[];
+}>;
+/** 写下 planVaultMemory 算好的:先重读,和算的时候不一样(家长刚存了一版)就不写,回为什么;写成回 null。先 .tmp 再 rename */
+export declare function writeVaultMemory(v: Vault, plan: MemoryPlan): Promise<string | null>;