cotutor 0.3.0 → 0.4.0

package/dist/brain/index.d.ts

@@ -1,24 +1,20 @@
 /**
  * 脑执行:一轮教学里「让脑想、写出正文」的那一步。
- * runner 拼好上下文包与系统提示交到这里;这里起老师(或接预热好的)、读输出、断流接着跑,随流回报正文与工具,收尾给出整轮的转录。
+ * runner 拼好上下文包与系统提示交到这里;这里请模型(应用直连百炼,./api.ts)、读输出,随流回报正文与工具,收尾给出整轮的转录。
  * 执行完不等于这一轮交付完:板书解析、配音、记忆与日记的收尾归 runner。
- * 两种实现,按 cotutor.json 里这轮的运行时分:{run, resume} 起 CLI(./cli/run.ts,各家方言在 ./cli/ 的适配器);{api, model} 应用直连模型(./api.ts)。
+ * 2026-11-02 以前还能起 Qwen Code(命令行);那时的轮次照样读得出(./log.ts),运行时用不了了(./runtime.ts)。
  */
-import { type CliEvent } from './cli/adapters.ts';
-import { type RunPlan } from './cli/run-plan.ts';
 import type { ToolCall, Transcript } from './transcript.ts';
-import { type CotutorConfig, type Policy, type Runtime } from '../schema/index.ts';
-import type { ToolSet } from './cli/adapters.ts';
-import type { Slot } from './cli/warm.ts';
-export type { ToolSet } from './cli/adapters.ts';
-export type { Slot } from './cli/warm.ts';
-/**
- * CLI 那一家给外面用的几样(经 brain 的出口给,外面不直接引 clis/):工具名属于哪一类(家长端看原文、板书写法有没有被读);
- * 出厂的运行时模板(init 写 cotutor.json);doctor 体检 CLI 运行时用的(退役没有、适配器、读输出、备机器文件、起进程的环境)
- */
-export { adapterFor, factoryRuntimes, parserOf, prepareCli, processEnv, runtimeIssue, toolKind, type ToolKind } from './cli/adapters.ts';
+import type { CotutorConfig, Policy } from '../schema/index.ts';
+import type { ToolSet } from './types.ts';
+import type { RunPlan } from './runtime.ts';
+import { type BrainLine } from './api.ts';
+export type { ToolKind, ToolSet } from './types.ts';
+export { toolKind } from './types.ts';
+export { parseLogLine } from './log.ts';
+export { RuntimeError, getRuntime, runtimeIssue, type RunPlan } from './runtime.ts';
 export { FACTORY_API_RUNTIMES } from './api.ts';
-/** 一轮要脑做的:哪个运行时、接哪个会话、系统提示的几样、这条消息(上下文包 + 孩子的话)、思考量、工具 */
+/** 一轮要脑做的:哪个运行时、接哪个会话、系统提示、这条消息(上下文包 + 孩子的话)、思考量、工具 */
 export interface BrainRequest {
     /** 运行时名,缺省 cotutor.json 的 runtimes.default */
     runtime?: string;
@@ -29,35 +25,24 @@ export interface BrainRequest {
     } | null;
     agent: string;
     prompt: string;
-    agentBody?: string;
+    /** 系统提示:老师正文(或 activity)+ 板书写法 */
     systemBody?: string;
-    boardFile?: string;
     effort?: Policy['effort'];
     tools: ToolSet;
-    /** 老师该读得到、在会话 cwd 外面的目录 */
+    /** 只读工具读得到的目录(workspace 根、vault) */
     readDirs: readonly string[];
-    /** 本轮附的照片(绝对路径):API 直接附成图;CLI 不用它,老师按上下文包里的路径自己读 */
+    /** 本轮附的照片(绝对路径),直接附成图 */
     images?: readonly string[];
-    /** 整段压缩(API 运行时;上一轮结束时上下文过了 32k):之前的模型历史不再发,digest 是应用照索引拼的前情;prompt 这一轮带笔记全文。CLI 不用它 */
+    /** 整段压缩(上一轮结束时上下文过了 32k):之前的模型历史不再发,digest 是应用照索引拼的前情;prompt 这一轮带笔记全文 */
     compact?: {
         digest: string;
     };
-    /** 回复停在写成正文的工具调用上了吗(板书的规矩,runner 交进来);CLI 据此 resume 一次告诉老师不会有结果,没给就不查。API 不用它 */
-    stuckOnTool?: (text: string) => boolean;
-}
-/** 接预热好的进程要对得上的:老师目录(进程 cwd)、日期、这个话题末条 job(新开记 null) */
-export interface WarmKey {
-    cwd: string;
-    date: string;
-    lastJob: string | null;
 }
 export interface BrainHooks {
-    /** 起了一次(第一次、断流接着跑、工具调用写成正文后接着跑);warmBornAt = 接过来的预热进程起来的时刻 */
     onStart(s: {
         cli: string;
         runtime: string;
         resume: boolean;
-        warmBornAt?: number;
     }): void;
     /** 当前回复的正文变了(读 BrainRun.text()) */
     onText(): void;
@@ -65,23 +50,16 @@ export interface BrainHooks {
         name: string;
         sub: boolean;
     }): void;
-    onStall(s: {
-        idleMs: number;
-        retry: number;
-        kept: number;
-    }): void;
-    /** 进程都退了,还没读日志收尾;at = Date.now() */
+    /** 模型回完了,还没读日志收尾;at = Date.now() */
     onExit(at: number): void;
 }
 export interface BrainRun {
-    /** 接的是预热好的进程 */
-    warm: boolean;
-    /** 当前这条回复的正文(断流接着跑的,含被杀那次已经写出的) */
+    /** 当前这条回复的正文 */
     text(): string;
     done: Promise<BrainResult>;
 }
 export interface BrainResult {
-    /** final 总有:进程退了没有收尾的,记成没成(原因指向 err.log) */
+    /** final 总有:没收尾的记成没成 */
     transcript: Transcript & {
         final: NonNullable<Transcript['final']>;
     };
@@ -90,56 +68,30 @@ export interface BrainResult {
     /** 给家长端这一轮的提醒,按出现顺序 */
     warnings: string[];
 }
-/** 这一轮落在哪:原始输出(CLI 的 stream-json / API 的统一事件)、stderr、这个话题的模型历史(API 用;CLI 的历史在它自己的会话里) */
+/** 这一轮落在哪:统一事件、stderr、这个话题的模型历史 */
 export interface BrainFiles {
     log: string;
     err: string;
     history: string;
 }
 export interface BrainExecutor {
-    /** 定这一轮怎么跑。现在就是 CLI 的命令规划(run 文件照记命令行);API 脑进来时再分出共同的 runtime / resume / session 与各家私有的 */
+    /** 定这一轮怎么跑:哪个运行时、接不接着会话(run 文件照记) */
     plan(req: BrainRequest): RunPlan;
-    /** 这一轮在 workspace 里要的机器文件(qwen 的隔离家目录);备不好照起,原因进 err.log */
-    prepare(plan: RunPlan): Promise<void>;
-    /**
-     * 跑一轮。同步返回:接预热进程在调用的这一拍里(调用方查完 busy 到这里之间不能有 await)。
-     * files:原始输出与 stderr 落哪;stall:断流看门狗
-     */
+    /** 跑一轮。files:统一事件与 stderr 落哪;stall:断流看门狗 */
     start(req: BrainRequest, plan: RunPlan, ctx: {
         tutor: string;
-        key: WarmKey;
         files: BrainFiles;
         stall: Policy['stall'];
     }, hooks: BrainHooks): BrainRun;
-    /** 这个运行时能不能预热(消息走 stdin 的才行) */
-    canWarm(runtime: Runtime): boolean;
-    /** 给下一轮起好进程;这个位置已有对得上的就不动 */
-    warm(tutor: string, slot: Slot, plan: RunPlan, key: WarmKey): void;
-    warmed(tutor: string, slot?: Slot): boolean;
-    dropWarm(tutor: string, slot?: Slot): void;
-    /** 杀掉所有预热的进程(测试收尾;服务退出时它们的 stdin 断了会自己退) */
-    close(): void;
 }
 /**
- * auth:百炼按量 key,知道的话带业务空间 id(API 运行时用;runner 给的是和实时那边同一条查找链);endpoint:测试与探针指到假百炼(…/compatible-mode/v1)
+ * line:这个模型发到哪、带哪把 key(runner 给 compatibleLine);endpoint:测试与探针指到假百炼(…/compatible-mode/v1)
  */
 export declare function createBrain(opts: {
     workspace: () => {
         config: CotutorConfig;
         root: string;
     };
-    env?: NodeJS.ProcessEnv;
-    warmIdleMs?: number;
-    auth?: () => {
-        key: string;
-        workspaceId: string | null;
-    } | null;
+    line?: BrainLine;
     endpoint?: string;
 }): BrainExecutor;
-/** 这个运行时关得住工具吗:关得住的,孩子那轮不带工具时,只有工具才用得上的路径(refs、vault)不进上下文包 */
-export declare function controlsTools(runtime: Runtime): boolean;
-/**
- * 读一轮的 .log:API 的轮次是一行一条统一事件,CLI 的按运行时的适配器读(运行时后来删了或改了按 stream-json)。
- * 两种行长得不一样(统一事件以 {"kind": 开头),一行一行认,运行时从 CLI 换成 API 以后,以前的轮次照样读得出
- */
-export declare function logParser(runtimes: Readonly<Record<string, unknown>>, name: string | undefined): (line: string) => CliEvent[];

package/dist/brain/index.js

@@ -1,74 +1,11 @@
-/**
- * 脑执行:一轮教学里「让脑想、写出正文」的那一步。
- * runner 拼好上下文包与系统提示交到这里;这里起老师(或接预热好的)、读输出、断流接着跑,随流回报正文与工具,收尾给出整轮的转录。
- * 执行完不等于这一轮交付完:板书解析、配音、记忆与日记的收尾归 runner。
- * 两种实现,按 cotutor.json 里这轮的运行时分:{run, resume} 起 CLI(./cli/run.ts,各家方言在 ./cli/ 的适配器);{api, model} 应用直连模型(./api.ts)。
- */
-import { controlsTools as cliControlsTools, parserForRuntime } from "./cli/adapters.js";
-import { getRuntime } from "./cli/run-plan.js";
-import { isApiRuntime } from "../schema/index.js";
-import { API_CLI, ApiBrain, parseEventLine } from "./api.js";
-import { CliBrain } from "./cli/run.js";
-/**
- * CLI 那一家给外面用的几样(经 brain 的出口给,外面不直接引 clis/):工具名属于哪一类(家长端看原文、板书写法有没有被读);
- * 出厂的运行时模板(init 写 cotutor.json);doctor 体检 CLI 运行时用的(退役没有、适配器、读输出、备机器文件、起进程的环境)
- */
-export { adapterFor, factoryRuntimes, parserOf, prepareCli, processEnv, runtimeIssue, toolKind } from "./cli/adapters.js";
+import { ApiBrain } from "./api.js";
+export { toolKind } from "./types.js";
+export { parseLogLine } from "./log.js";
+export { RuntimeError, getRuntime, runtimeIssue } from "./runtime.js";
 export { FACTORY_API_RUNTIMES } from "./api.js";
 /**
- * auth:百炼按量 key,知道的话带业务空间 id(API 运行时用;runner 给的是和实时那边同一条查找链);endpoint:测试与探针指到假百炼(…/compatible-mode/v1)
+ * line:这个模型发到哪、带哪把 key(runner 给 compatibleLine);endpoint:测试与探针指到假百炼(…/compatible-mode/v1)
  */
 export function createBrain(opts) {
-    return new Brains(opts.workspace, new CliBrain(opts), new ApiBrain({ workspace: opts.workspace, auth: opts.auth ?? (() => null), endpoint: opts.endpoint }));
-}
-/** 按这轮的运行时分给 CLI 或 API;预热只有 CLI 有 */
-class Brains {
-    workspace;
-    cli;
-    api;
-    constructor(workspace, cli, api) {
-        this.workspace = workspace;
-        this.cli = cli;
-        this.api = api;
-    }
-    plan(req) {
-        return isApiRuntime(getRuntime(this.workspace().config, req.runtime).runtime) ? this.api.plan(req) : this.cli.plan(req);
-    }
-    prepare(plan) {
-        return plan.cli === API_CLI ? Promise.resolve() : this.cli.prepare(plan);
-    }
-    start(req, plan, ctx, hooks) {
-        return plan.cli === API_CLI ? this.api.start(req, plan, ctx, hooks) : this.cli.start(req, plan, ctx, hooks);
-    }
-    canWarm(runtime) {
-        return !isApiRuntime(runtime) && this.cli.canWarm(runtime);
-    }
-    warm(tutor, slot, plan, key) {
-        if (plan.cli !== API_CLI)
-            this.cli.warm(tutor, slot, plan, key);
-    }
-    warmed(tutor, slot) {
-        return this.cli.warmed(tutor, slot);
-    }
-    dropWarm(tutor, slot) {
-        this.cli.dropWarm(tutor, slot);
-    }
-    close() {
-        this.cli.close();
-    }
-}
-/** 这个运行时关得住工具吗:关得住的,孩子那轮不带工具时,只有工具才用得上的路径(refs、vault)不进上下文包 */
-export function controlsTools(runtime) {
-    return isApiRuntime(runtime) || cliControlsTools(runtime);
-}
-/**
- * 读一轮的 .log:API 的轮次是一行一条统一事件,CLI 的按运行时的适配器读(运行时后来删了或改了按 stream-json)。
- * 两种行长得不一样(统一事件以 {"kind": 开头),一行一行认,运行时从 CLI 换成 API 以后,以前的轮次照样读得出
- */
-export function logParser(runtimes, name) {
-    const cli = parserForRuntime(runtimes, name);
-    return (line) => {
-        const e = parseEventLine(line);
-        return e.length ? e : cli(line);
-    };
+    return new ApiBrain({ workspace: opts.workspace, line: opts.line ?? (() => null), endpoint: opts.endpoint });
 }

package/dist/brain/log.d.ts

@@ -0,0 +1,5 @@
+import type { CliEvent } from './types.ts';
+/** 统一事件的一行;不是这种行回 [] */
+export declare function parseEventLine(line: string): CliEvent[];
+/** .log 的一行 → 统一事件:先当统一事件,不是再当旧的 stream-json */
+export declare function parseLogLine(line: string): CliEvent[];

package/dist/brain/log.js

@@ -0,0 +1,22 @@
+/**
+ * 一轮的 .log 怎么读:API 轮次一行一条统一事件({"kind": 开头,./api.ts 写的);2026-11-02 以前的轮次是 Qwen Code 的 stream-json(./stream-json.ts)。
+ * 两种行长得不一样,一行一行认,同一份记录里换过也读得出。
+ */
+import { parseStreamJson } from "./stream-json.js";
+/** 统一事件的一行;不是这种行回 [] */
+export function parseEventLine(line) {
+    if (!line.startsWith('{"kind":'))
+        return [];
+    try {
+        const e = JSON.parse(line);
+        return typeof e.kind === 'string' ? [e] : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** .log 的一行 → 统一事件:先当统一事件,不是再当旧的 stream-json */
+export function parseLogLine(line) {
+    const e = parseEventLine(line);
+    return e.length ? e : parseStreamJson(line);
+}

package/dist/brain/runtime.d.ts

@@ -0,0 +1,30 @@
+/**
+ * 这一轮用哪个运行时、接不接着会话。运行时只有 API 一种(`{api: "bailian", model}`,./api.ts)。
+ * 2026-11-02 起不再起命令行(Qwen Code;Claude CLI 10-28 就去掉了):旧 cotutor.json 里写着 `{run, resume}` 的照样读得进来,
+ * 但用不了——doctor 报出来,用到它的那位老师发不出去,说怎么改。以前那种运行时下聊的话题照样能看(sameRuntime:接不上、不记账)。
+ */
+import { type ApiRuntime, type CotutorConfig, type Runtime } from '../schema/index.ts';
+import type { ToolSet } from './types.ts';
+export interface RunPlan {
+    /** 运行时名(runtimes 里的键) */
+    runtime: string;
+    /** 哪种脑跑的(API 的是 api;旧轮次的 run.json 里是 CLI 的适配器名) */
+    cli: string;
+    /** 这轮带不带工具 */
+    tools: ToolSet;
+    /** 旧轮次起 CLI 的命令行;API 的是空 */
+    argv: string[];
+    /** 这次是接着会话还是新开 */
+    resume: boolean;
+    /** 接着的会话 id */
+    session: string | null;
+    env: Record<string, string>;
+}
+export declare class RuntimeError extends Error {
+}
+/** 命令行运行时(旧配置里的 `{run, resume}`)用不了,说怎么改;API 运行时 null */
+export declare function runtimeIssue(runtime: Runtime): string | null;
+export declare function getRuntime(config: CotutorConfig, name?: string): {
+    name: string;
+    runtime: ApiRuntime;
+};

package/dist/brain/runtime.js

@@ -0,0 +1,23 @@
+/**
+ * 这一轮用哪个运行时、接不接着会话。运行时只有 API 一种(`{api: "bailian", model}`,./api.ts)。
+ * 2026-11-02 起不再起命令行(Qwen Code;Claude CLI 10-28 就去掉了):旧 cotutor.json 里写着 `{run, resume}` 的照样读得进来,
+ * 但用不了——doctor 报出来,用到它的那位老师发不出去,说怎么改。以前那种运行时下聊的话题照样能看(sameRuntime:接不上、不记账)。
+ */
+import { isApiRuntime } from "../schema/index.js";
+export class RuntimeError extends Error {
+}
+/** 命令行运行时(旧配置里的 `{run, resume}`)用不了,说怎么改;API 运行时 null */
+export function runtimeIssue(runtime) {
+    return isApiRuntime(runtime) ? null : '命令行运行时(Qwen Code 等)2026-11-02 起不再支持:把 runtimes.default 和 tutors.*.runtime 改成 api 或 api-flash(应用直连百炼),再删掉这一条';
+}
+export function getRuntime(config, name) {
+    const n = name ?? config.runtimes.default;
+    const p = config.runtimes[n];
+    if (n === 'default' || !p || typeof p === 'string') {
+        const known = Object.keys(config.runtimes).filter((k) => k !== 'default');
+        throw new RuntimeError(`运行时 "${n}" 不存在;cotutor.json 的 runtimes 里有:${known.join('、')}`);
+    }
+    if (!isApiRuntime(p))
+        throw new RuntimeError(`运行时 "${n}":${runtimeIssue(p)}`);
+    return { name: n, runtime: p };
+}

package/dist/brain/{cli/stream-json.d.ts → stream-json.d.ts}

@@ -1,6 +1,6 @@
 /**
- * Qwen Code 的 stream-json(`--output-format stream-json`,一行一个 JSON)读成统一事件。
- * 同时保留历史日志的费用字段解析,让已有对话仍能查看。Qwen Code 0.25 的输出:
+ * 旧轮次的 .log:2026-11-02 以前老师的脑是起 Qwen Code(或更早的 Claude Code),输出是 stream-json(一行一个 JSON),这里读成统一事件,
+ * 那时的记录照样能看(看原文、读了什么、转录)。不再起 CLI,只读。Qwen Code 0.25 的输出:
  * - `{"type":"system","subtype":"init","session_id","tools":[…]}`(qwen 的 json 模式叫 session_start)
  * - `{"type":"stream_event","event":{…}}`:`--include-partial-messages` 才有;message_start 开新的一条,content_block_delta 的 text_delta 是正文、thinking_delta 是在想
  * - `{"type":"assistant","message":{"id","content":[text / tool_use 块],"usage"}}`:一条整的回复;usage 是这一次请求自己的
@@ -14,5 +14,3 @@ import type { CliEvent } from './types.ts';
 /** 结果块的文字:字符串原样,块数组拼各块的 text */
 export declare const blockText: (c: unknown) => string;
 export declare function parseStreamJson(line: string): CliEvent[];
-/** stream-json 输入的一条用户消息(`--input-format stream-json` 一行一条) */
-export declare function streamJsonUserMessage(prompt: string): string;

package/dist/brain/{cli/stream-json.js → stream-json.js}

@@ -80,7 +80,3 @@ export function parseStreamJson(line) {
     }
     return out;
 }
-/** stream-json 输入的一条用户消息(`--input-format stream-json` 一行一条) */
-export function streamJsonUserMessage(prompt) {
-    return `${JSON.stringify({ type: 'user', message: { role: 'user', content: prompt } })}\n`;
-}

package/dist/brain/stream.d.ts

@@ -1,11 +1,11 @@
 /**
- * 流式:老师还在说的时候,从 CLI 的输出事件里拼出「当前这条顶层回复的正文」,给板书的 partial 解析用。
- * 有增量的 CLI(claude 加 `--include-partial-messages`、qwen 0.25 同)每个字来一条 delta,每条新回复前有 start;没有增量开关的只有整条 assistant——两种都认:
+ * 流式:老师还在说的时候,从脑的输出事件里拼出「当前这条顶层回复的正文」,给板书的 partial 解析用。
+ * 增量来的每一小段是一条 delta,每条新回复前有 start;只有整条 assistant 的(旧轮次的一些 CLI)也认:
  * delta 往当前文本上追加,start 时当前段带围栏或 H2 就留下(与 kid-view 的 kidSource 同一条规则:老师板书完再用工具,卡不丢)、否则丢掉,
  * 新段从空开始;顶层 assistant 的正文直接当作当前段(与拼出来的一样)。text() = 留下的段 + 当前段。
- * 子代理的一律跳过。读哪家的输出由 CLI 适配器定(src/brain/cli/),这里只认统一事件。
+ * 子代理的一律跳过(旧轮次的 CLI 才有)。这里只认统一事件(./log.ts 读)。
  */
-import { type CliEvent } from './cli/types.ts';
+import { type CliEvent } from './types.ts';
 export interface PartialReader {
     /** 喂一块 stdout(原始字节,行没收完的先攒着);返回文本有没有变 */
     feed(chunk: string): boolean;
@@ -16,5 +16,5 @@ export interface PartialReader {
     /** 只要当前这段(还没收到整条 assistant 的那段;断流时它没进会话,要递回给老师) */
     current(): string;
 }
-/** parse:一行输出 → 统一事件(CLI 适配器的 parse);缺省按 stream-json 读 */
+/** parse:一行输出 → 统一事件;缺省 parseLogLine(统一事件,旧轮次的 stream-json 也认) */
 export declare function createPartialReader(parse?: (line: string) => CliEvent[]): PartialReader;

package/dist/brain/stream.js

@@ -1,15 +1,15 @@
 /**
- * 流式:老师还在说的时候,从 CLI 的输出事件里拼出「当前这条顶层回复的正文」,给板书的 partial 解析用。
- * 有增量的 CLI(claude 加 `--include-partial-messages`、qwen 0.25 同)每个字来一条 delta,每条新回复前有 start;没有增量开关的只有整条 assistant——两种都认:
+ * 流式:老师还在说的时候,从脑的输出事件里拼出「当前这条顶层回复的正文」,给板书的 partial 解析用。
+ * 增量来的每一小段是一条 delta,每条新回复前有 start;只有整条 assistant 的(旧轮次的一些 CLI)也认:
  * delta 往当前文本上追加,start 时当前段带围栏或 H2 就留下(与 kid-view 的 kidSource 同一条规则:老师板书完再用工具,卡不丢)、否则丢掉,
  * 新段从空开始;顶层 assistant 的正文直接当作当前段(与拼出来的一样)。text() = 留下的段 + 当前段。
- * 子代理的一律跳过。读哪家的输出由 CLI 适配器定(src/brain/cli/),这里只认统一事件。
+ * 子代理的一律跳过(旧轮次的 CLI 才有)。这里只认统一事件(./log.ts 读)。
  */
-import { parseStreamJson } from "./cli/stream-json.js";
-import { textsOf } from "./cli/types.js";
+import { parseLogLine } from "./log.js";
+import { textsOf } from "./types.js";
 const KEEP = /^\s*(?:```|~~~|## )/m;
-/** parse:一行输出 → 统一事件(CLI 适配器的 parse);缺省按 stream-json 读 */
-export function createPartialReader(parse = parseStreamJson) {
+/** parse:一行输出 → 统一事件;缺省 parseLogLine(统一事件,旧轮次的 stream-json 也认) */
+export function createPartialReader(parse = parseLogLine) {
     let rest = '';
     let text = '';
     // 当前段收到过整条 assistant 了(已进会话,不算「断在半截」)

package/dist/brain/transcript.d.ts

@@ -1,5 +1,5 @@
-import type { CliEvent, CliFinal } from './cli/types.ts';
-/** 一行输出 → 统一事件(CLI 适配器的 parse) */
+import type { CliEvent, CliFinal } from './types.ts';
+/** 一行输出 → 统一事件(./log.ts) */
 export type LineParser = (line: string) => CliEvent[];
 export interface TranscriptItem {
     /** text 说话 / tool 用工具 / tool-error 工具报错 / done 收尾 */
@@ -12,7 +12,7 @@ export type TranscriptRow = TranscriptItem | {
     kind: 'fold';
     tools: TranscriptItem[];
 };
-/** 收尾:result 的最终正文、成没成、费用或 token(见 src/brain/cli/types.ts 的 CliFinal) */
+/** 收尾:result 的最终正文、成没成、费用或 token(见 ./types.ts 的 CliFinal) */
 export type TranscriptFinal = CliFinal;
 export interface Transcript {
     sessionId: string | null;

package/dist/brain/transcript.js

@@ -1,9 +1,9 @@
 /**
- * 老师进程的转录(.log,一行一个 JSON)→ 家长视图条目 + 最终文本。起初抄自 growth-apps 的 gen-transcript(2026-08-26,claude 2.1.220),
- * 现在按 CLI 适配器读成统一事件再拼(src/brain/cli/,缺省 stream-json,claude / qwen 同族):子代理的条目标 sub,
- * 收尾的最终正文单独取出作 final——各家 CLI 都有的稳定锚点,孩子视图只看它。
+ * 一轮的转录(.log,一行一个 JSON)→ 家长视图条目 + 最终文本。起初抄自 growth-apps 的 gen-transcript(2026-08-26,claude 2.1.220),
+ * 现在读成统一事件再拼(./log.ts:API 轮次的统一事件,旧轮次的 stream-json):子代理的条目标 sub(旧轮次的 CLI 才有),
+ * 收尾的最终正文单独取出作 final,孩子视图只看它。
  */
-import { parseStreamJson } from "./cli/stream-json.js";
+import { parseLogLine } from "./log.js";
 import { tokenText } from "../shared/tokens.js";
 const FOLD_AT = 3;
 /**
@@ -58,7 +58,7 @@ export function toolArg(input) {
     }
     return '';
 }
-export function toolCalls(text, parse = parseStreamJson) {
+export function toolCalls(text, parse = parseLogLine) {
     const calls = [];
     const byId = new Map();
     for (const line of text.split('\n')) {
@@ -86,7 +86,7 @@ export function toolCalls(text, parse = parseStreamJson) {
     }
     return calls;
 }
-export function parseTranscript(text, parse = parseStreamJson) {
+export function parseTranscript(text, parse = parseLogLine) {
     let sessionId = null;
     const items = [];
     let final = null;

package/dist/brain/{cli/types.d.ts → types.d.ts}

@@ -1,12 +1,10 @@
 /**
- * CLI 适配器:一个 agent CLI 一个文件,写「这个 CLI 怎么说话」——
- * 输出流怎么读、消息怎么写进 stdin、工具叫什么怎么关、思考量怎么调、起进程要什么环境、出厂模板长什么样。
- * 选哪个模型、预算、时限还在 cotutor.json 的运行时模板里(数据);应用的其余部分只认这里的统一事件,不认哪家的 JSON。
- * 接一个新 CLI:照 qwen.ts 写一个文件,在 index.ts 的 ADAPTERS 里登记。
+ * 脑的统一事件与工具:API 脑(./api.ts)写进 .log、孩子端的流式板书、家长端看原文、转录都只认这些。
+ * 名字里的 Cli 是 2026-11-02 以前起 Qwen Code 时留下的;那时的 .log 是 stream-json,由 ./stream-json.ts 读成同样的事件。
  */
-import type { CliRuntime, Policy } from '../../schema/index.ts';
 /** 工具的类别:应用要知道「读了哪个文件」「是不是用技能回读板书写法」时按类别认,不比工具名 */
 export type ToolKind = 'read' | 'shell' | 'search' | 'edit' | 'skill' | 'other';
+export declare const toolKind: (name: string) => ToolKind;
 /**
  * 这轮带不带工具(政策 tools 与消息种类定):off 一个不带;read 只读(看照片、读 vault、查教材);
  * on 与 read 一样只读,不提供 shell 与写入工具
@@ -99,46 +97,3 @@ export type CliEvent = {
     kind: 'result';
     final: CliFinal;
 };
-/** 运行时模板里与适配器有关的占位能拿到的值 */
-export interface PlanContext {
-    /** workspace 根(适配器的私有文件放在它的 .cotutor/ 下);测试与不关心的调用可以不给 */
-    root?: string;
-    effort: Policy['effort'];
-    /** 这轮带不带工具 */
-    tools: ToolSet;
-}
-export interface CliAdapter {
-    /** 适配器名:运行时的 cli 字段,或 run[0] 的文件名 */
-    name: string;
-    /** 一行原始输出 → 统一事件;读不懂的行返回 [] */
-    parse(line: string): CliEvent[];
-    /** stdin 模式(运行时 stdin: "stream-json")下写进 stdin 的那一行用户消息,带换行 */
-    stdinMessage(prompt: string): string;
-    /** 模板里 `{tools}` 填什么(一个参数里的文字) */
-    toolList(set: ToolSet): string;
-    /** 模板里独占一个参数的 `{toolArgs}` 展开成哪几个参数(可以是零个);readDirs = 这轮该读得到的目录(workspace 根、vault),会话 cwd 是老师目录,它们在 cwd 外面 */
-    toolArgs(set: ToolSet, ctx: {
-        readDirs: readonly string[];
-    }): string[];
-    toolKind(name: string): ToolKind;
-    /** 这轮带或不带工具时,进程起来报的工具表(init 事件)应该正好是哪几样;多出来的记提醒(CLI 升版本会带进新工具)。不给 = 不核对 */
-    expectedTools?(set: ToolSet): readonly string[];
-    /** 起进程前把这个 CLI 在 workspace 里要的机器文件备好(幂等,内容一样就不写) */
-    prepare?(root: string): Promise<void>;
-    /** 由这轮的计划定下来的环境变量(进预热的比对:变了的备用进程不能用);没有就不写 */
-    planEnv?(ctx: PlanContext): Record<string, string>;
-    /** 起进程前最后过一遍环境(认证等);不改就原样返回 */
-    env(env: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
-    /** cotutor doctor 查这个 CLI 时多看几样(version 是 `--version` 的第一行);不给就只查装没装 */
-    check?(ctx: {
-        version: string;
-        env: NodeJS.ProcessEnv;
-    }): {
-        name: string;
-        ok: boolean;
-        detail: string;
-        fix?: string;
-    }[];
-    /** 出厂运行时模板:键是运行时名 */
-    runtimes(): Record<string, CliRuntime>;
-}

package/dist/brain/types.js

@@ -0,0 +1,14 @@
+/**
+ * 脑的统一事件与工具:API 脑(./api.ts)写进 .log、孩子端的流式板书、家长端看原文、转录都只认这些。
+ * 名字里的 Cli 是 2026-11-02 以前起 Qwen Code 时留下的;那时的 .log 是 stream-json,由 ./stream-json.ts 读成同样的事件。
+ */
+/** 工具名 → 类别:API 脑的三样(./api-tools.ts)与旧轮次里 Qwen Code、Claude Code 的工具名;不认识的是 other */
+const TOOL_KINDS = {
+    read_file: 'read', read_many_files: 'read', zoom_image: 'read', list_directory: 'read', glob: 'search', grep_search: 'search',
+    run_shell_command: 'shell', edit: 'edit', write_file: 'edit', notebook_edit: 'edit', skill: 'skill',
+    Read: 'read', Bash: 'shell', Grep: 'search', Glob: 'search', Edit: 'edit', Write: 'edit', NotebookEdit: 'edit', MultiEdit: 'edit', Skill: 'skill',
+};
+export const toolKind = (name) => TOOL_KINDS[name] ?? 'other';
+/** 一条回复的正文段 / 工具调用 */
+export const textsOf = (parts) => parts.flatMap((p) => (p.type === 'text' ? [p.text] : []));
+export const toolsOf = (parts) => parts.flatMap((p) => (p.type === 'tool' ? [p.tool] : []));

package/dist/chalk/glyphs/skeleton.d.ts

@@ -35,9 +35,9 @@ export interface GlyphPenOptions {
     /** 采样步长(归一化单位);缺省 SAMPLE_STEP。调小更平滑,但动画 DOM 体积约按平方涨 */
     sampleStep?: number;
     /**
-     * 字形表(provider):缺省内置拉丁包(a–z / A–Z)。扩展字形数据包
-     * (如 drawtell-glyphs-hanzi)导出同构的 Map,从这里传入即共用同一支笔——
-     * 归一化约定由各包自定并写明(拉丁 = 四线三格;汉字 = 格子高 1、底线 y=0、顶 y=-1)。
+     * 字形表(provider):缺省内置拉丁包(a–z / A–Z)。别的字形做成同构的 Map 从这里传入,就和字母共用同一支笔;
+     * 归一化约定由传入方定并写明(拉丁 = 四线三格;汉字可取格子高 1、底线 y=0、顶 y=-1)。
+     * 汉字要逐笔写时从 hanzi-writer-data 的 medians 现做(本包已依赖它,田字格卡就读它),不另挑字表。
      */
     glyphs?: ReadonlyMap<string, Glyph>;
 }

package/dist/chalk/glyphs/skeleton.js

@@ -45,7 +45,7 @@ export class UnknownGlyphError extends Error {
     /** node 的 strip-only 类型擦除不支持构造函数参数属性,字段显式声明 */
     ch;
     constructor(ch) {
-        super(`字形表未收录 '${ch}'。内置包只有 a–z 与 A–Z;汉字等扩展字形经 glyphs 选项传入(如 drawtell-glyphs-hanzi)。`);
+        super(`字形表未收录 '${ch}'。内置包只有 a–z 与 A–Z;别的字形做成同构的 Map 经 glyphs 选项传入。`);
         this.ch = ch;
     }
 }

package/dist/lib/index.d.ts

@@ -11,5 +11,5 @@ export * from '../memory/plan.ts';
 export * from '../runtime/journal/ledger.ts';
 export * from '../runtime/journal/conversation.ts';
 export * from '../shared/time.ts';
-export * from '../brain/cli/run-plan.ts';
+export * from '../brain/runtime.ts';
 export * from '../memory/timetable.ts';

package/dist/lib/index.js

@@ -11,5 +11,5 @@ export * from "../memory/plan.js";
 export * from "../runtime/journal/ledger.js";
 export * from "../runtime/journal/conversation.js";
 export * from "../shared/time.js";
-export * from "../brain/cli/run-plan.js";
+export * from "../brain/runtime.js";
 export * from "../memory/timetable.js";

package/dist/memory/diary.js

@@ -1,11 +1,11 @@
-import { threads } from "../schema/index.js";
+import { threads, viaSendsLabel } from "../schema/index.js";
 /** 孩子在这个话题里说的话:from: kid、不是「继续」/ 交答案这种动作、非空;多行并成一行 */
 export function kidQuestions(messages, thread) {
     const ths = threads(messages);
     const out = [];
     messages.forEach((m, i) => {
-        // 首页的开场 / 接着按钮发的是按钮上的字,不是孩子说的
-        if (ths[i] !== thread || m.from !== 'kid' || m.action || (m.via && typeof m.via.button === 'number'))
+        // 首页的开场 / 接着按钮、方砖发的是按钮上的字,不是孩子说的
+        if (ths[i] !== thread || m.from !== 'kid' || m.action || (m.via && viaSendsLabel(m.via)))
             return;
         const text = m.text.replace(/\s+/g, ' ').trim();
         if (text && text !== '继续')

package/dist/realtime/bailian.d.ts

@@ -55,7 +55,7 @@ export interface RealtimeEvents {
     onError?(message: string): void;
     onClose?(reason: string): void;
 }
-/** 百炼按量的 key 与业务空间 id(Token Plan 没有 omni realtime;key 怎么找见 src/shared/qianwen.ts,业务空间 id 先看家长端配的、再看环境、再看 voxtell 的配置) */
+/** 百炼按量的 key 与业务空间 id(Token Plan 没有 omni realtime;都在 ~/.config/cotutor/bailian.json,见 src/shared/qianwen.ts) */
 export declare function dashscopeAuth(env?: NodeJS.ProcessEnv): {
     key: string;
     workspaceId: string;

package/dist/realtime/bailian.js

@@ -28,7 +28,7 @@ export const OUTPUT_RATE = 24000;
 export const MAX_IMAGE_B64 = 262144 - 1024;
 const TRANSCRIBE_MODEL = 'qwen3-asr-flash-realtime';
 const HEARTBEAT_PCM = Buffer.alloc(INPUT_RATE * 2);
-/** 百炼按量的 key 与业务空间 id(Token Plan 没有 omni realtime;key 怎么找见 src/shared/qianwen.ts,业务空间 id 先看家长端配的、再看环境、再看 voxtell 的配置) */
+/** 百炼按量的 key 与业务空间 id(Token Plan 没有 omni realtime;都在 ~/.config/cotutor/bailian.json,见 src/shared/qianwen.ts) */
 export function dashscopeAuth(env = process.env) {
     const key = qianwenKeys(env).payg;
     const workspaceId = bailianWorkspaceId(env);
@@ -95,8 +95,9 @@ export class RealtimeSession {
     async connect() {
         let url = this.opts.endpoint;
         let key = '';
+        // 指了端点的是测试与探针的假百炼,不看 key
         if (url)
-            key = this.opts.env?.DASHSCOPE_API_KEY ?? 'sk-test';
+            key = 'sk-test';
         else {
             const auth = this.opts.auth ?? dashscopeAuth(this.opts.env);
             if (!auth)