cotutor 0.3.0 → 0.4.0

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 = 到的墙钟(现连时补的那几条照原来到的时刻记事件) */

package/dist/runtime/live/call.js

@@ -7,7 +7,7 @@
  * 没念的拍丢掉,孩子听到第几句(src/runtime/delivery/playback.ts 按声音排到哪算)进下一轮的上下文包 live:。嘴只接住、只照念,不讲新内容(2026-10-19 P1);画板开着时例外(边画边聊,见下)。
  *
  * 孩子端 → 这里:二进制帧 = PCM16 16k 单声道一块(按着时才推);文本帧 = JSON
- *   {t:'hold'} 按下 · {t:'release', body} 松手(body 同 POST /api/kid/conversations/<老师>/messages 少 text:thread / newThread / device…)
+ *   {t:'hold'} 按下 · {t:'release', body} 松手(body 同 send 的那条少 text:thread / newThread / device…,runner.accept 验)
  *   {t:'hush'} 停下不开新一轮(上滑取消):嘴在出就掐、孩子端清了、没念的丢掉
  *   {t:'send', body} 不是说的(打字、拍照、交卡、首页按钮;舞台开着带 focus.card):body 同那条 POST · {t:'view', w, h} 屏幕多大 · {t:'bye'}
  *   {t:'staged'} 讲稿 [[play]] 的小课堂那一段放完了(或放不了、被关):后面的讲稿接着交给嘴
@@ -31,12 +31,15 @@
  *   孩子说完(像跟读,src/scenes/talk/warmup.ts)开闸下一拍,不接住、不交脑;对老师说的照收下办(打断、接住、交脑);ECHO_WAIT_MS 没开口接着走,连着两拍没开口停下交脑(app: quiet)。
  *   每拍记进摸底(录像 {t:'echo'},只记不发),交脑时带上(live.warmup)。[[call]] 那句念完孩子端响铃,这里马上交脑一轮(app: call,不接住),
  *   之后的接住换英文(cue.ts 的 CATCH_EN),交脑带打电话几分钟(live.phone)。孩子端连上发来的第一条带 talk(口语单)时嘴先说「好,我们先热热身!」。
- * 录像:进出的消息、两边的声音都记(CallRecorder),挂了落在 conversations/<老师>/<日期>.live/<时分秒>.reel.json / .wav。
+ * 录像:进出的消息、两边的声音都记(CallRecorder),落在 conversations/<老师>/<日期>.live/<时分秒>.reel.json / .wav(时分秒 = 这一段开始的时刻)。
+ *   按段落(2026-11-06):两轮之间安静着(心跳时看),这一段 IDLE_CUT_MS 没动静、或录了 MAX_TAKE_MS,就收下这一段落盘、接着录新的一段;挂了落最后一段。
+ *   一段一轮都不会切开(录像按轮在一段里找按下、松手、turn、read);没动静的一段不落。
  * 字幕重放:嘴照念的声音按轮另留一份,出了的都留(孩子按下时清掉、没放出来的也在),
  *   一段出完(或被掐、断了)就落 <日期>.<job>.mouth.wav 与每句的起点 .mouth.json(src/runtime/journal/mouth-index.ts);接住那句不在里面。孩子端从 /api/kid/conversations/<老师>/mouth/<日期>/<job> 取。
  * 事件:嘴这一道(mouth:按下、松手 / 发了、接住开始放、第几句开始放、打断)补进那一轮的 events.jsonl(Runner.noteEvent),工作台的时间线上看;
  * 按下、松手、接住在脑起来之前,先攒着,等那一轮的老师进程起来(main:start)再按它的起点换成相对毫秒(负的)。
  */
+import { existsSync } from 'node:fs';
 import { mkdir, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { localDate } from "../../shared/time.js";
@@ -50,7 +53,7 @@ import { wavOfPcm } from "../../shared/wav.js";
 import { mouthInstructions } from "../../realtime/prompt.js";
 import { mouthVoice } from "../../schema/index.js";
 import { INPUT_RATE, MAX_IMAGE_B64, OUTPUT_RATE, RealtimeSession } from "../../realtime/bailian.js";
-import { CallRecorder } from "../journal/recorder.js";
+import { CallRecorder, renderTake } from "../journal/recorder.js";
 import { MouthEvents, MouthTakes } from "../journal/mouth.js";
 import { Turns } from "./turns.js";
 /** 嘴接住的那句最多等多久再把孩子的话交给脑(接住的字一般 1 秒内齐;脑知道嘴说了什么,第一句就不再重复) */
@@ -77,6 +80,12 @@ const IDLE_SWAP_MS = 240_000;
 /** 热身:[[echo]] / [[say]] 那句在孩子端放完,这么久没开口就接着下一拍(不催);连着这么多拍没开口就停下交脑 */
 const ECHO_WAIT_MS = 8000;
 const QUIET_BEATS = 2;
+/**
+ * 录像切段:这一段这么久没动静、或录了这么久(两轮之间安静着才切),就收下落盘、接着录新的一段。
+ * 页面开着不关能挂几个钟头(2026-10-25 一段 2 小时、361 MB 的 wav,几乎没说话):不切的话声音全攒在内存里,挂断时一起混
+ */
+const IDLE_CUT_MS = 5 * 60_000;
+const MAX_TAKE_MS = 30 * 60_000;
 /** 打电话:[[call]] 那句放完先响这么久的铃,脑的英文开场来得再早也等它(孩子听得到在打电话) */
 const RING_MS = 3000;
 /**
@@ -170,6 +179,8 @@ export class LiveCall {
     chatQuiet = 0;
     chatQuietUntil = 0;
     offEvents = null;
+    /** 录像一段一段排着落盘(按顺序、一次混一段);挂了等它们都落完 */
+    saving = Promise.resolve();
     ended = false;
     sock;
     deps;
@@ -526,6 +537,7 @@ export class LiveCall {
     keepAlive() {
         const s = this.session;
         this.maybeSwap();
+        this.maybeCut();
         if (!s?.isReady || this.holding || this.vadOn || s.responding || Date.now() - this.lastActive > (this.deps.keepAliveMs ?? KEEP_ALIVE_MS))
             return;
         // 一直听、声音一直在推:本来就有输入,不用跳
@@ -563,6 +575,32 @@ export class LiveCall {
             this.send({ t: 'flush' });
         }
     }
+    /**
+     * 录像切段:两轮之间安静着(孩子没在说、嘴没在说也没在放、脑没在写、没在等转写),这一段没动静够久了或录得够长了,就收下落盘。
+     * 一轮不会被切开:录像按轮在一段里找按下、松手、turn 和 read
+     */
+    maybeCut() {
+        if (this.ended || !this.quiet() || this.playing() || this.pendingVoice || this.draft || this.echoing || this.chatHeard !== null)
+            return;
+        const idle = this.rec.quietMs() >= (this.deps.idleCutMs ?? IDLE_CUT_MS);
+        const long = this.rec.stirred && this.rec.takeMs() >= (this.deps.maxTakeMs ?? MAX_TAKE_MS);
+        if (idle || long)
+            this.saveTake(this.rec.cut());
+    }
+    /** 落一段录像(排在前面那几段后面):没动静的、只有连上那两条的不落 */
+    saveTake(raw) {
+        if (!raw.stirred || raw.msgs.length <= 2)
+            return;
+        const { ctx, tutor } = this.deps;
+        this.saving = this.saving.then(async () => {
+            const take = await renderTake(raw);
+            const dir = join(ctx.runner.ws.dirs.conversations, tutor, `${localDate(raw.startedAt)}.live`);
+            await mkdir(dir, { recursive: true });
+            const name = takeName(dir, raw.startedAt);
+            await writeFile(join(dir, `${name}.wav`), wavOfPcm(take.callPcm, MIX_RATE));
+            await writeFile(join(dir, `${name}.reel.json`), JSON.stringify(take.reel));
+        }).catch((err) => { console.error('live: 录像落盘失败', err); });
+    }
     /** 孩子的一条文本消息 */
     onText(raw) {
         if (this.ended)
@@ -1155,21 +1193,8 @@ export class LiveCall {
         if (this.said?.kind === 'read')
             this.mouthEnd(this.said, false);
         await this.takes.flush();
-        try {
-            const take = this.rec.finish();
-            if (take.reel.msgs.length > 2) {
-                const { ctx, tutor } = this.deps;
-                const at = this.rec.startedAt;
-                const dir = join(ctx.runner.ws.dirs.conversations, tutor, `${localDate(at)}.live`);
-                const name = [at.getHours(), at.getMinutes(), at.getSeconds()].map((n) => String(n).padStart(2, '0')).join('');
-                await mkdir(dir, { recursive: true });
-                await writeFile(join(dir, `${name}.wav`), wavOfPcm(take.callPcm, MIX_RATE));
-                await writeFile(join(dir, `${name}.reel.json`), JSON.stringify(take.reel));
-            }
-        }
-        catch (err) {
-            console.error('live: 录像落盘失败', err);
-        }
+        this.saveTake(this.rec.finish());
+        await this.saving;
         this.sock.close(1000, why);
         this.deps.onFinished?.(why);
     }
@@ -1178,6 +1203,14 @@ export class LiveCall {
         void this.end('kid-gone'); }
 }
 const isObj = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+/** 一段录像的文件名:开始的时分秒;这一秒已经有一段了(同一位老师两次通话、切段撞在同一秒)往后挪一秒,不盖掉 */
+const takeName = (dir, at) => {
+    const hms = (d) => [d.getHours(), d.getMinutes(), d.getSeconds()].map((n) => String(n).padStart(2, '0')).join('');
+    let name = hms(at);
+    for (let k = 1; k < 60 && existsSync(join(dir, `${name}.reel.json`)); k++)
+        name = hms(new Date(at.getTime() + k * 1000));
+    return name;
+};
 /** 孩子端发来的图(data:image/jpeg;base64,…)→ 字节;不是 jpeg、太大(百炼一帧上限)回 null */
 const jpegOf = (v) => {
     const m = typeof v === 'string' ? /^data:image\/jpeg;base64,([A-Za-z0-9+/=]+)$/.exec(v) : null;

package/dist/runtime/live/turns.js

@@ -1,6 +1,6 @@
 /**
  * 实时那一轮交给脑(从 call.ts 拆出来,2026-10-29,行为不变;以后是 runtime/turn):
- * 孩子端发来的那条验过、拼好(runner.accept,和 HTTP 共用),带上这一轮实时的那些(live:)交给 runner.send;
+ * 孩子端发来的那条验过、拼好(runner.accept;孩子端只走这条路,HTTP 的发 2026-11-04 删了),带上这一轮实时的那些(live:)交给 runner.send;
  * 这位老师别处正在写(BusyError)就排着,它写完把排着的几句合并成一条再发;脑在写时孩子又说的(submit 时 running)也排着,这一轮写完一起发。
  * 一轮写完,收尾时把流式没发出来的讲稿从正式的一节补上(整块出的运行时、最后几句)。
  */