cotutor 0.3.0 → 0.4.1

package/dist/runtime/home/store.js

@@ -10,10 +10,10 @@ import { UsageError } from "../../shared/errors.js";
 import { localDate } from "../../shared/time.js";
 import { conversationFiles, threads } from "../../schema/index.js";
 import { kidQuestions } from "../../memory/diary.js";
-import { activityFile } from "../activities.js";
+import { activityName, findActivityFile } from "../activities.js";
 import { lintActivity, parseActivity, resolveParams } from "../activity.js";
-import { arrangeHome, dropFixes, homeActivities, homeOwners, faceTutor, homeId, homeIssues, homeLectures, homeRefs, homeTutors, kidButtons, parseHome, threadKey, todayResumes } from "./home.js";
-import { HOME_ID_RE, LECTURE_ACTIVITY, PublishedHomeSchema } from "../../schema/index.js";
+import { arrangeHome, dropFixes, homeActivities, homeOwners, faceTutor, homeId, homeIssues, homeLectures, homeRefs, homeTutors, kidButtons, kidTiles, parseHome, threadKey, todayResumes } from "./home.js";
+import { HOME_ID_RE, HOME_TILES, LECTURE_ACTIVITY, PublishedHomeSchema, tutorTiles } from "../../schema/index.js";
 import { listDates, readCardStates, readIndex } from "../journal/store.js";
 import { bakeSoon, inspectLecture, readLecture } from "../lecture.js";
 export function homeFiles(ws) {
@@ -78,10 +78,10 @@ async function checkContext(ws, doc, now) {
     }
     const activities = new Map();
     for (const r of homeActivities(doc)) {
-        const text = await readFile(activityFile(ws.root, r.tutor, r.name), 'utf8').catch(() => null);
+        const text = await readFile(findActivityFile(ws.root, r.tutor, r.name), 'utf8').catch(() => null);
         if (text === null)
             continue;
-        const { activity, issues } = lintActivity(text, { fileName: r.name, tutorCards: ws.config.tutors[r.tutor]?.cards });
+        const { activity, issues } = lintActivity(text, { fileName: activityName(ws.root, r.tutor, r.name), tutorCards: ws.config.tutors[r.tutor]?.cards });
         activities.set(`${r.tutor}/${r.name}`, { activity, fixes: issues.filter((i) => i.level === 'fix').length });
     }
     return { tutors: tutorInfos(ws), threads: await liveThreads(ws, homeRefs(doc)), lectures, lectureProblems, unbaked, today: localDate(now), activities };
@@ -93,10 +93,10 @@ export async function checkHome(ws, md, now) {
 }
 /** 孩子端能不能用这个 activity:文件在、检查没有「要改」(提醒不算);用不了 → null */
 export async function usableActivity(ws, tutor, name) {
-    const text = await readFile(activityFile(ws.root, tutor, name), 'utf8').catch(() => null);
+    const text = await readFile(findActivityFile(ws.root, tutor, name), 'utf8').catch(() => null);
     if (text === null)
         return null;
-    const { activity, issues } = lintActivity(text, { fileName: name, tutorCards: ws.config.tutors[tutor]?.cards });
+    const { activity, issues } = lintActivity(text, { fileName: activityName(ws.root, tutor, name), tutorCards: ws.config.tutors[tutor]?.cards });
     return issues.some((i) => i.level === 'fix') ? null : activity;
 }
 /** 已发布那份里现在还坏着的引用(doctor 与家长端用) */
@@ -112,7 +112,7 @@ export async function publishHome(ws, opts) {
     const f = homeFiles(ws);
     const src = opts.from ? (isAbsolute(opts.from) ? opts.from : resolve(ws.root, opts.from)) : f.draft;
     const md = await readFile(src, 'utf8').catch(() => null);
-    const shown = relative(ws.root, src) || src;
+    const shown = relative(ws.root, src).split(sep).join('/') || src;
     if (md === null)
         throw new UsageError(opts.from ? `读不到 ${opts.from}` : '还没有草稿 home/draft.md(用 cotutor-home 技能写一份)');
     return publishHomeMd(ws, md, shown, opts);
@@ -233,8 +233,9 @@ export async function kidHomeView(ws, now, opts = {}) {
             continue;
         }
         const name = String(c.props.tutor);
+        const resumes = await resumesOf(ws, name, today);
         const buttons = kidButtons((c.props.buttons ?? []), {
-            resumes: await resumesOf(ws, name, today),
+            resumes,
             alive: (date, thread) => alive.has(threadKey(name, date, thread)),
             lecture: (bundle) => Boolean(lectures.get(bundle)),
             activity: (a, params) => { const act = usable.get(`${name}/${a}`); return Boolean(act) && resolveParams(act, params).issues.length === 0; },
@@ -244,7 +245,12 @@ export async function kidHomeView(ws, now, opts = {}) {
         // 橙点:这份首页给他排了按钮或卡,而发布以来孩子还没找过他
         const arranged = buttons.some((b) => typeof b.id === 'number') || cards.some((x) => x.kind !== 'tutor' && owners.get(x) === name);
         const news = Boolean(publishedAt && arranged && !(await talkedSince(ws, name, publishedAt, now)));
-        out.push({ kind: 'tutor', props: { tutor: name, buttons, ...(news ? { news: true } : {}) } });
+        // 常驻的方砖(预习、检查作业、复习):不经发布,家里有那个 activity、没关掉就在
+        const tiles = [];
+        for (const t of HOME_TILES)
+            if (tutorTiles(ws.config.tutors[name] ?? {}).includes(t.id) && (await usableActivity(ws, name, t.activity)))
+                tiles.push(t.id);
+        out.push({ kind: 'tutor', props: { tutor: name, buttons, tiles: kidTiles(tiles, { usable: () => true, resumes }), ...(news ? { news: true } : {}) } });
     }
     return { home: id, cards: out };
 }
@@ -259,7 +265,23 @@ export async function resolveVia(ws, tutor, via) {
         return { kind: 'new', label: '新话题' };
     if (via.button === 'recent')
         return { kind: 'recent', label: '接着刚才的' };
-    if (via.home === null)
+    // activity 的参数在点的那一刻按 activity 文件解析、补缺省,跟着话题走(家长后来改了只管以后的话题);文件不在、参数不对 → null
+    const runOf = async (name, params) => {
+        const text = await readFile(findActivityFile(ws.root, tutor, name), 'utf8').catch(() => null);
+        if (text === null)
+            return null;
+        const r = resolveParams(parseActivity(text).activity, params);
+        return r.issues.length ? null : { name, params: r.values };
+    };
+    // 方砖:不看是哪份首页(缺省首页也有);关掉了、家里那个 activity 用不了 → null。参数全用缺省(三份都可空,老师先请孩子拍材料)
+    const tile = HOME_TILES.find((t) => t.id === via.button);
+    if (tile) {
+        if (!tutorTiles(ws.config.tutors[tutor] ?? {}).includes(tile.id) || !(await usableActivity(ws, tutor, tile.activity)))
+            return null;
+        const run = await runOf(tile.activity, {});
+        return run ? { kind: 'activity', label: tile.activity, activity: tile.activity, params: run.params } : null;
+    }
+    if (via.home === null || typeof via.button !== 'number')
         return null;
     const { home } = await readPublished(ws);
     if (!home || home.id !== via.home)
@@ -271,14 +293,6 @@ export async function resolveVia(ws, tutor, via) {
     const brief = b.brief ? { brief: b.brief } : {};
     if (b.kind === 'start')
         return { kind: 'start', label: b.label, ...brief };
-    // activity 的参数在点的那一刻按 activity 文件解析、补缺省,跟着话题走(家长后来改了只管以后的话题);文件不在、参数不对 → null
-    const runOf = async (name, params) => {
-        const text = await readFile(activityFile(ws.root, tutor, name), 'utf8').catch(() => null);
-        if (text === null)
-            return null;
-        const r = resolveParams(parseActivity(text).activity, params);
-        return r.issues.length ? null : { name, params: r.values };
-    };
     // 小课堂看完照哪个 activity 聊:写了 activity: 是它,没写是这位老师的「小课堂」;文件不在 → null
     if (b.kind === 'lecture') {
         const run = await runOf(b.activity ?? LECTURE_ACTIVITY, {});
@@ -393,7 +407,8 @@ export function formatCheck(ws, check, title, kid) {
             const ref = b.kind === 'continue' ? ` → ${b.date} ${b.thread}` : b.kind === 'lecture' ? ` → 小课堂 ${b.bundle}` : act?.kind === 'activity' ? ` → activity ${act.activity}${Object.keys(act.params).length ? `(${Object.entries(act.params).map(([k, v]) => `${k}: ${v}`).join(';')})` : ''}` : '';
             return `${BUTTON_ICON[b.kind]} ${b.label}${ref}${brief}`;
         });
-        out.push(`  ${display(name)} ${name}${written.has(name) ? '' : '(没写,应用补)'}:${buttons.join(' | ')}`);
+        const tiles = (c.props.tiles ?? []).map((x) => `▦ ${x.label}`);
+        out.push(`  ${display(name)} ${name}${written.has(name) ? '' : '(没写,应用补)'}:${[...buttons.slice(0, 1), ...tiles, ...buttons.slice(1)].join(' | ')}${tiles.length ? '(▦ 是常驻的方砖,不用写)' : ''}`);
     }
     const rest = kid.cards.filter((x) => x.kind !== 'tutor');
     if (rest.length) {
@@ -424,7 +439,7 @@ export function formatStats(ws, s) {
     const h = s.home;
     const tutorsN = h.cards.filter((c) => c.kind === 'tutor').length;
     const out = [`已发布 ${h.id}(${s.days === 0 ? '今天' : `${s.days} 天前`}${h.for ? `,for ${h.for}` : ''})· ${tutorsN} 张老师卡 · ${h.cards.length - tutorsN} 张别的卡 · 原文 ${h.source}`];
-    const icon = (b) => (b === 'new' ? '✨' : b === 'recent' ? '↻' : '·');
+    const icon = (b) => (b === 'new' ? '✨' : b === 'recent' ? '↻' : typeof b === 'string' ? '▦' : '·');
     for (const c of s.clicks) {
         const who = ws.config.tutors[c.tutor]?.display ?? c.tutor;
         out.push(`  ${who} ${icon(c.button)} ${c.label}:${c.uses.length ? `点了 ${c.uses.length} 次(${c.uses.map((u) => `${u.date} ${u.thread}`).join('、')})` : '没点过'}`);

package/dist/runtime/journal/mix.d.ts

@@ -20,14 +20,23 @@ export declare function playingOf(segs: {
     start: number;
     end: number;
 }[]): [number, number][];
-/** 两边混成一条(PCM16 单声道 24k,长到 ms 为止;挂断那一刻还没放完的老师的声音不要) */
+/** 混出来的一条 + 老师出声的时段 + 孩子有声的时段 */
+export interface Mixed {
+    pcm: Buffer;
+    playing: [number, number][];
+    kidVoice: [number, number][];
+}
+/** 一口气混完(测试、短的) */
 export declare function mixCall(o: {
     kid: Chunk[];
     tutor: Chunk[];
     flushes: number[];
     ms: number;
-}): {
-    pcm: Buffer;
-    playing: [number, number][];
-    kidVoice: [number, number][];
-};
+}): Mixed;
+/** 分片混:结果同 mixCall,中间让出事件循环(通话里落录像走这个) */
+export declare function mixCallSliced(o: {
+    kid: Chunk[];
+    tutor: Chunk[];
+    flushes: number[];
+    ms: number;
+}): Promise<Mixed>;

package/dist/runtime/journal/mix.js

@@ -53,36 +53,77 @@ export function playingOf(segs) {
     }
     return out.map(([a, b]) => [Math.round(a), Math.round(b)]);
 }
-/** 两边混成一条(PCM16 单声道 24k,长到 ms 为止;挂断那一刻还没放完的老师的声音不要) */
-export function mixCall(o) {
+/** 分片混:每混这么多个采样(10 秒)让一下事件循环——通话中切段时就在混,不能卡住正在说的那一路 */
+const SLICE_SAMPLES = MIX_RATE * 10;
+/**
+ * 两边混成一条(PCM16 单声道 24k,长到 ms 为止;挂断那一刻还没放完的老师的声音不要)。
+ * 直接往 Int16 里加、加一次削一次顶(两边叠着才会削,和先加完再削只差一个最低位);不另开整段的 Float32(一个钟头就是 345 MB)。
+ * 生成器:每混 SLICE_SAMPLES 个采样 yield 一次,mixCall 一口气跑完,mixCallSliced 每次 yield 让一下事件循环
+ */
+function* mixing(o) {
     const n = Math.max(0, Math.round((o.ms * MIX_RATE) / 1000));
-    const acc = new Float32Array(n);
-    const put = (at, i16, len) => {
-        const base = Math.round((at * MIX_RATE) / 1000);
-        for (let k = 0; k < len; k++) {
-            const j = base + k;
-            if (j >= 0 && j < n)
-                acc[j] += i16(k);
-        }
+    const pcm = Buffer.alloc(n * 2);
+    let work = 0;
+    const add = (j, v) => {
+        const s = pcm.readInt16LE(j * 2) + Math.round(v);
+        pcm.writeInt16LE(s > 32767 ? 32767 : s < -32768 ? -32768 : s, j * 2);
     };
+    const voiced = [];
     for (const c of o.kid) {
         const m = samplesOf(c.pcm);
         if (!m)
             continue;
         const len = Math.floor((m * MIX_RATE) / KID_RATE);
         const at = c.t - (m * 1000) / KID_RATE;
-        put(at, (k) => {
+        const base = Math.round((at * MIX_RATE) / 1000);
+        for (let k = 0; k < len; k++) {
+            const j = base + k;
+            if (j < 0 || j >= n)
+                continue;
             const x = (k * KID_RATE) / MIX_RATE, i = Math.floor(x), f = x - i;
             const a = c.pcm.readInt16LE(Math.min(i, m - 1) * 2), b = c.pcm.readInt16LE(Math.min(i + 1, m - 1) * 2);
-            return a + (b - a) * f;
-        }, len);
+            add(j, a + (b - a) * f);
+        }
+        if (rms(c.pcm) >= KID_VOICE)
+            voiced.push({ start: at, end: c.t });
+        work += len;
+        if (work >= SLICE_SAMPLES) {
+            work = 0;
+            yield;
+        }
     }
     const segs = scheduleTutor(o.tutor, o.flushes).filter((s) => s.start < o.ms);
-    for (const s of segs)
-        put(s.start, (k) => s.pcm.readInt16LE(k * 2), samplesOf(s.pcm));
-    const pcm = Buffer.alloc(n * 2);
-    for (let j = 0; j < n; j++)
-        pcm.writeInt16LE(Math.max(-32768, Math.min(32767, Math.round(acc[j]))), j * 2);
-    const voiced = o.kid.filter((c) => rms(c.pcm) >= KID_VOICE).map((c) => ({ start: c.t - (samplesOf(c.pcm) * 1000) / KID_RATE, end: c.t }));
+    for (const s of segs) {
+        const base = Math.round((s.start * MIX_RATE) / 1000);
+        const len = samplesOf(s.pcm);
+        for (let k = 0; k < len; k++) {
+            const j = base + k;
+            if (j >= 0 && j < n)
+                add(j, s.pcm.readInt16LE(k * 2));
+        }
+        work += len;
+        if (work >= SLICE_SAMPLES) {
+            work = 0;
+            yield;
+        }
+    }
     return { pcm, playing: playingOf(segs.map((s) => ({ start: s.start, end: Math.min(s.end, o.ms) }))), kidVoice: playingOf(voiced) };
 }
+/** 一口气混完(测试、短的) */
+export function mixCall(o) {
+    const g = mixing(o);
+    let r = g.next();
+    while (!r.done)
+        r = g.next();
+    return r.value;
+}
+/** 分片混:结果同 mixCall,中间让出事件循环(通话里落录像走这个) */
+export async function mixCallSliced(o) {
+    const g = mixing(o);
+    let r = g.next();
+    while (!r.done) {
+        await new Promise((resolve) => setImmediate(resolve));
+        r = g.next();
+    }
+    return r.value;
+}

package/dist/runtime/journal/recorder.d.ts

@@ -1,5 +1,16 @@
+/**
+ * 一次通话的录像记录(录数据,不录屏幕):口语课与实时老师共用。
+ * 发给孩子端(o)/ 孩子端发来(i)的每条消息带离开始的毫秒;两边的声音每块带到达的毫秒;孩子端清播放队列的时刻;屏幕多大。
+ * 按段收(2026-11-06):页面开着不关,一通电话能挂几个钟头,声音全攒在内存里挂断时再混,一个钟头就上 G。
+ *   cut() 收下这一段、接着录新的一段;什么时候切由调用方定(call.ts:两轮之间安静着、没动静够久了或这一段够长了)。
+ *   ms() 一直是离通话开始的毫秒(调用方的时钟,切段不动它);收下的那一段里的时刻都换成离这一段开始的毫秒。
+ *   一段尾巴上没动静的那截不要(TAKE_TAIL_MS 之后);没动静的一段收下来 stirred = false,调用方丢掉;
+ *   没动静的一段第一次有动静时,TAKE_LEAD_MS 之前的那截丢掉(孩子走开一个钟头再回来,录像不从一个钟头前开始)。
+ * 收下的(RawTake)交给 renderTake:两边按到达时刻混成一条(src/runtime/journal/mix.ts,分片混、不卡事件循环),给出录像的数据(reel.json 的形状)与要落盘的声音;落在哪由调用方定。
+ */
+import { type Chunk } from './mix.ts';
 export type ReelMsg = [number, 'o' | 'i', Record<string, unknown>];
-/** reel.json:消息、老师出声的时段、孩子有声的时段、屏幕多大;声音另在 call.wav(24k 单声道) */
+/** reel.json:消息、老师出声的时段、孩子有声的时段、屏幕多大;声音另在同名的 .wav(24k 单声道) */
 export interface CallReel {
     v: 1;
     startedAt: string;
@@ -9,38 +20,72 @@ export interface CallReel {
     playing: [number, number][];
     kidVoice: [number, number][];
 }
+/** 收下的一段,还没混:时刻都是离这一段开始的毫秒(开始之前到的块是负的,混的时候落在外面的不要) */
+export interface RawTake {
+    startedAt: Date;
+    ms: number;
+    view: [number, number] | null;
+    msgs: ReelMsg[];
+    kid: Chunk[];
+    tutor: Chunk[];
+    flushes: number[];
+    /** 这一段有没有动静(孩子按下、发来、嘴说了……);没有的不落 */
+    stirred: boolean;
+}
 export interface CallTake {
     ms: number;
     reel: CallReel;
     /** 两边按时刻混好的一条(MIX_RATE) */
     callPcm: Buffer;
-    /** 两边各自首尾相接(孩子 16k、老师 24k),没有时刻 */
-    kidPcm: Buffer;
-    tutorPcm: Buffer;
 }
+/** 一段尾巴上:最后一次动静之后留这么久 */
+export declare const TAKE_TAIL_MS = 2000;
+/** 一段开头:第一次动静之前留这么久 */
+export declare const TAKE_LEAD_MS = 2000;
 export declare class CallRecorder {
     readonly startedAt: Date;
     private readonly now;
-    private readonly msgs;
-    private readonly kidChunks;
-    private readonly tutorChunks;
-    private readonly flushes;
+    private msgs;
+    private kidChunks;
+    private tutorChunks;
+    private flushes;
     private size;
+    /** 这一段从哪一刻起(离通话开始的毫秒) */
+    private base;
+    /** 这一段最后一次动静(老师的声音算到它在孩子端放完);没动静时 = base */
+    private lastStir;
+    private stirredNow;
+    /** 老师的声音在孩子端排到哪(估的,flush 不截;只用来算最后一次动静) */
+    private tutorEnd;
     constructor(now?: () => Date);
-    /** 离开始多少毫秒 */
+    /** 离通话开始多少毫秒(切段不动它) */
     ms(): number;
+    /** 这一段多久没动静了 */
+    quietMs(): number;
+    /** 这一段录了多久 */
+    takeMs(): number;
+    /** 这一段有过动静没有 */
+    get stirred(): boolean;
     /** 发给孩子端的一条;{t:'flush'} 同时记下清队列的时刻 */
     out(m: Record<string, unknown>): void;
     /** 孩子端发来的一条 */
     in(m: Record<string, unknown>, t?: number): void;
     /** 孩子端清了播放队列,但没有一条 flush 消息(比如换段时页面自己清) */
     flush(): void;
-    /** 孩子的一块声音(16k);t 缺省现在(开口前垫上的那几块带自己到的时刻) */
+    /** 孩子的一块声音(16k);t 缺省现在(开口前垫上的那几块带自己到的时刻)。不算动静:一直听时没人说话也一直在推 */
     kid(pcm: Buffer, t?: number): void;
-    /** 老师的一块声音(24k) */
+    /** 老师的一块声音(24k):算动静,算到它在孩子端放完 */
     tutor(pcm: Buffer): void;
     /** 孩子端报的屏幕尺寸;不像样的不记 */
     view(w: unknown, h: unknown): void;
-    /** 收:混声音、拼录像的数据(ms 缺省现在) */
-    finish(ms?: number): CallTake;
+    /** 收这一段,从现在起录新的一段(调用方在两轮之间安静时切) */
+    cut(): RawTake;
+    /** 挂了:收最后一段(ms 缺省现在) */
+    finish(ms?: number): RawTake;
+    /** 有动静:这一段头一次有动静就把 TAKE_LEAD_MS 之前的丢掉 */
+    private stir;
+    /** 这一段到 end 为止(有动静的截到最后一次动静 + TAKE_TAIL_MS),时刻换成离这一段开始的毫秒 */
+    private take;
 }
+/** 混声音、拼录像的数据(分片混,不卡事件循环) */
+export declare function renderTake(raw: RawTake): Promise<CallTake>;

package/dist/runtime/journal/recorder.js

@@ -1,9 +1,24 @@
 /**
  * 一次通话的录像记录(录数据,不录屏幕):口语课与实时老师共用。
  * 发给孩子端(o)/ 孩子端发来(i)的每条消息带离开始的毫秒;两边的声音每块带到达的毫秒;孩子端清播放队列的时刻;屏幕多大。
- * 挂了 finish:两边按到达时刻混成一条(src/runtime/journal/mix.ts),给出录像的数据(reel.json 的形状)与要落盘的声音;落在哪、还落什么由调用方定。
+ * 按段收(2026-11-06):页面开着不关,一通电话能挂几个钟头,声音全攒在内存里挂断时再混,一个钟头就上 G。
+ *   cut() 收下这一段、接着录新的一段;什么时候切由调用方定(call.ts:两轮之间安静着、没动静够久了或这一段够长了)。
+ *   ms() 一直是离通话开始的毫秒(调用方的时钟,切段不动它);收下的那一段里的时刻都换成离这一段开始的毫秒。
+ *   一段尾巴上没动静的那截不要(TAKE_TAIL_MS 之后);没动静的一段收下来 stirred = false,调用方丢掉;
+ *   没动静的一段第一次有动静时,TAKE_LEAD_MS 之前的那截丢掉(孩子走开一个钟头再回来,录像不从一个钟头前开始)。
+ * 收下的(RawTake)交给 renderTake:两边按到达时刻混成一条(src/runtime/journal/mix.ts,分片混、不卡事件循环),给出录像的数据(reel.json 的形状)与要落盘的声音;落在哪由调用方定。
  */
-import { mixCall } from "./mix.js";
+import { mixCallSliced } from "./mix.js";
+/** 一段尾巴上:最后一次动静之后留这么久 */
+export const TAKE_TAIL_MS = 2000;
+/** 一段开头:第一次动静之前留这么久 */
+export const TAKE_LEAD_MS = 2000;
+/** 不算动静的:孩子端报屏幕尺寸、说再见;嘴连上、换连接、断了、挂断(只记不发的那几条也在) */
+const STILL_IN = new Set(['view', 'bye']);
+const STILL_OUT = new Set(['ready', 'swap', 'lost', 'down', 'end']);
+/** 孩子端排老师的声音起步(同 mix.ts 的 LEAD_MS):估这块放完的时刻用 */
+const TUTOR_LEAD_MS = 60;
+const TUTOR_RATE = 24000;
 export class CallRecorder {
     startedAt;
     now;
@@ -12,21 +27,40 @@ export class CallRecorder {
     tutorChunks = [];
     flushes = [];
     size = null;
+    /** 这一段从哪一刻起(离通话开始的毫秒) */
+    base = 0;
+    /** 这一段最后一次动静(老师的声音算到它在孩子端放完);没动静时 = base */
+    lastStir = 0;
+    stirredNow = false;
+    /** 老师的声音在孩子端排到哪(估的,flush 不截;只用来算最后一次动静) */
+    tutorEnd = 0;
     constructor(now = () => new Date()) {
         this.now = now;
         this.startedAt = now();
     }
-    /** 离开始多少毫秒 */
+    /** 离通话开始多少毫秒(切段不动它) */
     ms() { return this.now().getTime() - this.startedAt.getTime(); }
+    /** 这一段多久没动静了 */
+    quietMs() { return this.ms() - this.lastStir; }
+    /** 这一段录了多久 */
+    takeMs() { return this.ms() - this.base; }
+    /** 这一段有过动静没有 */
+    get stirred() { return this.stirredNow; }
     /** 发给孩子端的一条;{t:'flush'} 同时记下清队列的时刻 */
     out(m) {
         const t = this.ms();
         this.msgs.push([t, 'o', m]);
-        if (m.t === 'flush')
+        if (m.t === 'flush') {
             this.flushes.push(t);
+            this.tutorEnd = 0;
+        }
+        if (!STILL_OUT.has(String(m.t)))
+            this.stir(t);
     }
     /** 孩子端发来的一条 */
     in(m, t = this.ms()) {
+        if (!STILL_IN.has(String(m.t)))
+            this.stir(t);
         // 一直听时孩子那一句的开口 / 说完(补记的 hold / release)要记回它当时的时刻,按时刻插进去,录像按顺序读
         let i = this.msgs.length;
         while (i > 0 && this.msgs[i - 1][0] > t)
@@ -34,25 +68,81 @@ export class CallRecorder {
         this.msgs.splice(i, 0, [t, 'i', m]);
     }
     /** 孩子端清了播放队列,但没有一条 flush 消息(比如换段时页面自己清) */
-    flush() { this.flushes.push(this.ms()); }
-    /** 孩子的一块声音(16k);t 缺省现在(开口前垫上的那几块带自己到的时刻) */
+    flush() {
+        const t = this.ms();
+        this.flushes.push(t);
+        this.tutorEnd = 0;
+        this.stir(t);
+    }
+    /** 孩子的一块声音(16k);t 缺省现在(开口前垫上的那几块带自己到的时刻)。不算动静:一直听时没人说话也一直在推 */
     kid(pcm, t = this.ms()) { this.kidChunks.push({ t, pcm }); }
-    /** 老师的一块声音(24k) */
-    tutor(pcm) { this.tutorChunks.push({ t: this.ms(), pcm }); }
+    /** 老师的一块声音(24k):算动静,算到它在孩子端放完 */
+    tutor(pcm) {
+        const t = this.ms();
+        this.tutorChunks.push({ t, pcm });
+        this.tutorEnd = Math.max(t + TUTOR_LEAD_MS, this.tutorEnd) + ((pcm.length >> 1) * 1000) / TUTOR_RATE;
+        this.stir(t);
+        this.lastStir = Math.max(this.lastStir, this.tutorEnd);
+    }
     /** 孩子端报的屏幕尺寸;不像样的不记 */
     view(w, h) {
         if (typeof w === 'number' && typeof h === 'number' && w > 0 && h > 0)
             this.size = [Math.round(w), Math.round(h)];
     }
-    /** 收:混声音、拼录像的数据(ms 缺省现在) */
-    finish(ms = this.ms()) {
-        const mix = mixCall({ kid: this.kidChunks, tutor: this.tutorChunks, flushes: this.flushes, ms });
+    /** 收这一段,从现在起录新的一段(调用方在两轮之间安静时切) */
+    cut() {
+        const now = this.ms();
+        const raw = this.take(now);
+        this.msgs = [];
+        this.kidChunks = [];
+        this.tutorChunks = [];
+        this.flushes = [];
+        this.base = now;
+        this.lastStir = now;
+        this.stirredNow = false;
+        this.tutorEnd = 0;
+        return raw;
+    }
+    /** 挂了:收最后一段(ms 缺省现在) */
+    finish(ms = this.ms()) { return this.take(ms); }
+    /** 有动静:这一段头一次有动静就把 TAKE_LEAD_MS 之前的丢掉 */
+    stir(t) {
+        if (!this.stirredNow) {
+            this.stirredNow = true;
+            const from = t - TAKE_LEAD_MS;
+            if (from > this.base) {
+                this.base = from;
+                this.msgs = this.msgs.filter(([at]) => at >= from);
+                this.kidChunks = this.kidChunks.filter((c) => c.t > from);
+                this.tutorChunks = this.tutorChunks.filter((c) => c.t > from);
+                this.flushes = this.flushes.filter((at) => at >= from);
+            }
+        }
+        if (t > this.lastStir)
+            this.lastStir = t;
+    }
+    /** 这一段到 end 为止(有动静的截到最后一次动静 + TAKE_TAIL_MS),时刻换成离这一段开始的毫秒 */
+    take(end) {
+        const b = this.base;
+        const stop = this.stirredNow ? Math.min(end, this.lastStir + TAKE_TAIL_MS) : end;
         return {
-            ms,
-            reel: { v: 1, startedAt: this.startedAt.toISOString(), ms, view: this.size, msgs: this.msgs, playing: mix.playing, kidVoice: mix.kidVoice },
-            callPcm: mix.pcm,
-            kidPcm: Buffer.concat(this.kidChunks.map((c) => c.pcm)),
-            tutorPcm: Buffer.concat(this.tutorChunks.map((c) => c.pcm)),
+            startedAt: new Date(this.startedAt.getTime() + b),
+            ms: Math.max(0, Math.round(stop - b)),
+            view: this.size,
+            msgs: this.msgs.map(([t, d, m]) => [Math.max(0, t - b), d, m]),
+            kid: this.kidChunks.map((c) => ({ t: c.t - b, pcm: c.pcm })),
+            tutor: this.tutorChunks.map((c) => ({ t: c.t - b, pcm: c.pcm })),
+            flushes: this.flushes.map((t) => t - b),
+            stirred: this.stirredNow,
         };
     }
 }
+/** 混声音、拼录像的数据(分片混,不卡事件循环) */
+export async function renderTake(raw) {
+    const mix = await mixCallSliced({ kid: raw.kid, tutor: raw.tutor, flushes: raw.flushes, ms: raw.ms });
+    return {
+        ms: raw.ms,
+        reel: { v: 1, startedAt: raw.startedAt.toISOString(), ms: raw.ms, view: raw.view, msgs: raw.msgs, playing: mix.playing, kidVoice: mix.kidVoice },
+        callPcm: mix.pcm,
+    };
+}

package/dist/runtime/journal/store.d.ts

@@ -11,8 +11,8 @@ export declare function readIndex(ws: Workspace, tutor: string, date: string): P
 export declare function writeIndex(ws: Workspace, index: ConversationIndex): Promise<void>;
 /** 有过对话的日期,新的在前 */
 export declare function listDates(ws: Workspace, tutor: string): Promise<string[]>;
-/** runtime:这轮的运行时名(消息上记着),按它的 CLI 适配器读;不给按 stream-json */
-export declare function readTranscript(ws: Workspace, tutor: string, date: string, job: string, runtime?: string): Promise<Transcript | null>;
+/** 一轮的转录:统一事件,旧轮次的 stream-json 也读(src/brain/log.ts) */
+export declare function readTranscript(ws: Workspace, tutor: string, date: string, job: string): Promise<Transcript | null>;
 /**
  * 一天里卡的目录 <date>.<job>.cards/ 全扫一遍:<n>.json 是孩子做的事(坏文件跳过,孩子端不报),<n>/<k>.mp3 是后台生成好的资产。
  */
@@ -72,7 +72,7 @@ export interface RunFile {
     session: string | null;
     /** 老师文件与技能的快照;2026-09-15 之前的轮次没有 */
     sources?: RunSources;
-    /** 这个运行时把老师正文塞进了命令行({agentBody} / {systemBody}) */
+    /** 老师正文进了系统提示(API 运行时总是;旧轮次看那时的命令模板) */
     agentBody: boolean;
 }
 export declare function writeRunFile(ws: Workspace, tutor: string, date: string, job: string, r: {
@@ -91,7 +91,7 @@ export declare function readRunFile(ws: Workspace, tutor: string, date: string,
 export declare function readErrLog(ws: Workspace, tutor: string, date: string, job: string): Promise<string>;
 /** 这轮起跑时老师文件与技能长什么样(记进 run.json;读不到的就 null / 空,不拦这一轮) */
 export declare function snapshotSources(ws: Workspace, name: string): Promise<RunSources>;
-/** 老师文件正文(系统提示),给 {agentBody} / {systemBody};从 agents/<name>.md 读(所有运行时都从这里拿) */
+/** 老师文件正文(系统提示的前半);从 agents/<name>.md 读 */
 export declare function readAgentBody(ws: Workspace, name: string): Promise<string>;
 /** 给一个话题打星(1–5;null 清掉):话题要在这天的索引里;写回索引 */
 export declare function rateThread(ws: Workspace, tutor: string, date: string, thread: string, rating: number | null): Promise<ConversationIndex>;

package/dist/runtime/journal/store.js

@@ -10,7 +10,7 @@ import { emptyIndex } from "./conversation.js";
 import { localDate } from "../../shared/time.js";
 import { cardAssetName, conversationFiles, threads, tutorFilePath } from "../../schema/index.js";
 import { parseTranscript } from "../../brain/transcript.js";
-import { logParser } from "../../brain/index.js";
+import { parseLogLine } from "../../brain/index.js";
 import { ConversationIndexSchema, DATE_RE, explainIssues, } from "../../schema/index.js";
 import { undoThreadVault } from "../../memory/vault.js";
 import { recoverPending } from "../../memory/commit.js";
@@ -64,10 +64,10 @@ export async function listDates(ws, tutor) {
         return [];
     }
 }
-/** runtime:这轮的运行时名(消息上记着),按它的 CLI 适配器读;不给按 stream-json */
-export async function readTranscript(ws, tutor, date, job, runtime) {
+/** 一轮的转录:统一事件,旧轮次的 stream-json 也读(src/brain/log.ts) */
+export async function readTranscript(ws, tutor, date, job) {
     try {
-        return parseTranscript(await readFile(conversationFiles(ws.dirs.conversations, tutor, date).log(job), 'utf8'), logParser(ws.config.runtimes, runtime));
+        return parseTranscript(await readFile(conversationFiles(ws.dirs.conversations, tutor, date).log(job), 'utf8'), parseLogLine);
     }
     catch {
         return null;
@@ -209,7 +209,7 @@ export async function snapshotSources(ws, name) {
     const file = tutorFilePath(ws.dirs.agents, name);
     try {
         const body = await readFile(file, 'utf8');
-        agent = { file: relative(ws.root, file), hash: sha(body), body };
+        agent = { file: relative(ws.root, file).split(sep).join('/'), hash: sha(body), body };
     }
     catch {
         /* 读不到:记 null */
@@ -224,7 +224,7 @@ export async function snapshotSources(ws, name) {
     }
     return { agent, skills };
 }
-/** 老师文件正文(系统提示),给 {agentBody} / {systemBody};从 agents/<name>.md 读(所有运行时都从这里拿) */
+/** 老师文件正文(系统提示的前半);从 agents/<name>.md 读 */
 export async function readAgentBody(ws, name) {
     const file = tutorFilePath(ws.dirs.agents, name);
     try {

package/dist/runtime/kid-input.js

@@ -1,7 +1,6 @@
 /**
- * 孩子端发一条的验与拼:HTTP 的 POST /api/kid/conversations/<老师>/messages 与实时老师那条线(src/runtime/live/call.ts)共用,
- * 都经 Runner.accept 进来。验正文、话题、首页按钮、小课堂、activity、照片,拼成 Runner.send 的入参;不对回 reject(状态码 + 错误名),
- * 怎么告诉孩子端由各自的协议定(HTTP 回 JSON,WS 回 err)。不起老师。
+ * 孩子端发一条的验与拼:孩子端只走实时那条连接(src/runtime/live/turns.ts;HTTP 的发 2026-11-04 删了),经 Runner.accept 进来。
+ * 验正文、话题、首页按钮、小课堂、activity、照片,拼成 Runner.send 的入参;不对回 reject(状态码 + 错误名),连接上回 {t:'err'}。不起老师。
  */
 import { FocusSchema, HomeViaSchema, DeviceSchema } from "../schema/index.js";
 import { BUNDLE_ID_RE } from "../board/cards/kind.js";

package/dist/runtime/live/call.d.ts

@@ -30,6 +30,9 @@ export interface LiveDeps {
     ringMs?: number;
     /** 测试:要嘴说了多久一个字没出算卡住 */
     stallMs?: number;
+    /** 测试:录像这一段多久没动静、录了多久就切(心跳时看) */
+    idleCutMs?: number;
+    maxTakeMs?: number;
     onFinished?(why: string): void;
 }
 export declare class LiveCall {
@@ -110,6 +113,8 @@ export declare class LiveCall {
     private chatQuiet;
     private chatQuietUntil;
     private offEvents;
+    /** 录像一段一段排着落盘(按顺序、一次混一段);挂了等它们都落完 */
+    private saving;
     private ended;
     private readonly sock;
     private readonly deps;
@@ -155,6 +160,13 @@ export declare class LiveCall {
     private mouthEnd;
     /** 孩子按下(或不是说的那一轮开始):嘴在出就掐、还在放就清孩子端;排着的丢掉;记下孩子听到第几句 */
     private interrupt;
+    /**
+     * 录像切段:两轮之间安静着(孩子没在说、嘴没在说也没在放、脑没在写、没在等转写),这一段没动静够久了或录得够长了,就收下落盘。
+     * 一轮不会被切开:录像按轮在一段里找按下、松手、turn 和 read
+     */
+    private maybeCut;
+    /** 落一段录像(排在前面那几段后面):没动静的、只有连上那两条的不落 */
+    private saveTake;
     /** 孩子的一条文本消息 */
     onText(raw: string): void;
     /** 一条孩子端的消息;at = 到的墙钟(现连时补的那几条照原来到的时刻记事件) */