cotutor 0.3.0 → 0.4.1

package/dist/brain/api.js

@@ -1,5 +1,6 @@
 /**
  * 脑执行的 API 实现(2026-10-29):不起 CLI,应用在服务进程里直连百炼的 Chat Completions(AI SDK + @ai-sdk/alibaba,cotutor-api-prototype 验过这条路)。
+ * - 发到哪按模型选(src/shared/qianwen.ts 的 compatibleLine):Token Plan 有这个模型、本机有 token-plan.json 就走 Token Plan(2026-11-02 起),否则百炼按量
  * - 系统提示 = runner 给的 systemBody(老师正文或 activity + 板书写法);消息 = 上下文包 + 孩子的话,本轮的照片直接附成图,不靠老师自己去读
  * - 同一话题的模型历史应用自己存:<日期>.<话题>.brain.jsonl,一行一轮(会话 id、模型、这轮的用户消息、模型回的全部消息、成没成);
  *   接着话题时把同一会话的那几行拼回去。照片只记相对 workspace 根的路径,发的时候再编码。没回完的一轮只留写出来的正文,下一条消息前头注明
@@ -20,11 +21,11 @@ import { isStepCount, streamText } from 'ai';
 import { randomUUID } from 'node:crypto';
 import { createWriteStream } from 'node:fs';
 import { appendFile, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
-import { dirname, extname, isAbsolute, join, relative } from 'node:path';
-import { getRuntime } from "./cli/run-plan.js";
+import { dirname, extname, isAbsolute, join, relative, sep } from 'node:path';
+import { getRuntime } from "./runtime.js";
+import { parseEventLine } from "./log.js";
 import { createPartialReader } from "./stream.js";
 import { parseTranscript, toolCalls, toolSummary } from "./transcript.js";
-import { compatibleBase, DASHSCOPE_HOST } from "../shared/qianwen.js";
 import { isApiRuntime } from "../schema/index.js";
 import { readOnlyTools } from "./api-tools.js";
 /** 计划里记的 cli 名:API 的轮次按它分流 */
@@ -39,7 +40,7 @@ export const FACTORY_API_RUNTIMES = {
 const DEFAULT_STEPS = 6;
 /** 想一点:没有思考档的模型思考最多多少 token(有档的发 reasoning_effort,见 effortOf) */
 const THINK_LITTLE = 1024;
-/** 有思考档的模型:同 Qwen Code 里的 qwen3.8 系列(src/brain/cli/qwen.ts 的 tiers),百炼兼容接口认 reasoning_effort */
+/** 有思考档的模型:qwen3.8 系列(2026-10-31 照当时 Qwen Code 的档对过),百炼兼容接口认 reasoning_effort */
 const TIERED = /^qwen3\.8-/;
 /** 一张照片最大多少字节(百炼按 base64 收,太大的不附,记一条提醒) */
 const IMAGE_MAX = 10 * 1024 * 1024;
@@ -48,18 +49,6 @@ const MIME = { '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
 const CODEC = 'ai-sdk@7';
 /** 上一轮没回完:接在下一条消息前头 */
 const UNFINISHED = '(应用注:上一轮你没有回完,上面是写出来的那部分;孩子可能听到了一些,也可能没有,别当它已经说完。)';
-/** .log 的一行 → 统一事件(API 轮次的日志就是一行一条统一事件);不是这种行回 [] */
-export function parseEventLine(line) {
-    if (!line.startsWith('{"kind":'))
-        return [];
-    try {
-        const e = JSON.parse(line);
-        return typeof e.kind === 'string' ? [e] : [];
-    }
-    catch {
-        return [];
-    }
-}
 /** 政策 effort → 思考开关与思考量(同 qwen:low 不想,孩子在等;带工具的轮次至少想一点,不然照片题连资料都不查) */
 export function thinkingOf(effort, tools) {
     if (effort === 'high')
@@ -69,7 +58,7 @@ export function thinkingOf(effort, tools) {
     return { enableThinking: false };
 }
 /**
- * 有思考档的模型照 qwen 运行时发 reasoning_effort(src/brain/cli/qwen.ts 的 EFFORT):想一点 = low、不限 = xhigh;不想或没有档 → null,照 thinkingOf 发。
+ * 有思考档的模型发 reasoning_effort(照当时 Qwen Code 的档):想一点 = low、不限 = xhigh;不想或没有档 → null,照 thinkingOf 发。
  * low 是它自己看着想:闲聊想一两百 token,认照片题想得多;thinking_budget 是死卡,1024 时有照片的话题每轮都想满(2026-10-31)
  */
 export function effortOf(model, effort, tools) {
@@ -87,12 +76,6 @@ export function effortFetch(effort, base = fetch) {
         return base(input, { ...init, body: JSON.stringify({ ...body, reasoning_effort: effort }) });
     };
 }
-/**
- * 百炼 Chat Completions 的端点:知道业务空间 id 就走它的域名(原型验过,同 realtime);只有按量 key 就走公网域名(qwen 那边按量的线也走它,2026-10-29 真跑通)
- */
-export function bailianBase(workspaceId) {
-    return workspaceId ? `https://${workspaceId}.cn-beijing.maas.aliyuncs.com/compatible-mode/v1` : compatibleBase(DASHSCOPE_HOST);
-}
 /** 报错只说状态码:SDK 的异常里带着整个请求 */
 function failure(err) {
     const status = err && typeof err === 'object' && 'statusCode' in err ? err.statusCode : undefined;
@@ -213,12 +196,12 @@ async function pastOf(file, session, root, current) {
 }
 export class ApiBrain {
     workspace;
-    auth;
-    /** 测试与探针:…/compatible-mode/v1(假百炼);不给按业务空间 id 拼 */
+    line;
+    /** 测试与探针:…/compatible-mode/v1(假百炼);不给按模型选线 */
     endpoint;
     constructor(opts) {
         this.workspace = opts.workspace;
-        this.auth = opts.auth;
+        this.line = opts.line;
         this.endpoint = opts.endpoint;
     }
     plan(req) {
@@ -247,11 +230,11 @@ export class ApiBrain {
             const session = plan.session ?? `api-${randomUUID()}`;
             event({ kind: 'session', id: session });
             const images = req.images ?? [];
-            const stored = images.map((p) => { const rel = relative(root, p); return rel.startsWith('..') || isAbsolute(rel) ? p : rel; });
+            const stored = images.map((p) => { const rel = relative(root, p); return rel.startsWith('..') || isAbsolute(rel) ? p : rel.split(sep).join('/'); });
             const record = { v: 1, session, at: new Date().toISOString(), model: runtime.model, codec: CODEC, user: { text: req.prompt, images: stored }, messages: [], ok: false };
             let final;
-            const auth = this.auth();
-            if (!auth && !this.endpoint) {
+            const line = this.line(runtime.model);
+            if (!line && !this.endpoint) {
                 final = { ok: false, text: null, reason: 'auth:没有百炼按量 key' };
                 warnings.push('百炼还没配好(按量 key):家长端「首页」里填,这位老师的运行时是 API 的,没有它说不了话');
             }
@@ -267,7 +250,7 @@ export class ApiBrain {
                 }
                 const user = await userMessage(text, attach, root, warnings);
                 const tier = effortOf(runtime.model, req.effort, req.tools);
-                const alibaba = createAlibaba({ apiKey: auth?.key ?? 'sk-endpoint', baseURL: this.endpoint ?? bailianBase(auth.workspaceId), includeUsage: true, ...(tier ? { fetch: effortFetch(tier) } : {}) });
+                const alibaba = createAlibaba({ apiKey: line?.key ?? 'sk-endpoint', baseURL: this.endpoint ?? line.baseURL, includeUsage: true, ...(tier ? { fetch: effortFetch(tier) } : {}) });
                 // 断流看门狗:stall.ms 没有一块流到就停(工具在本进程里跑,几毫秒的事,不另算)
                 const abort = new AbortController();
                 let stalled = false;
@@ -296,7 +279,7 @@ export class ApiBrain {
                 try {
                     const result = streamText({
                         model: alibaba(runtime.model),
-                        ...(req.systemBody ?? req.agentBody ? { system: req.systemBody ?? req.agentBody } : {}),
+                        ...(req.systemBody ? { system: req.systemBody } : {}),
                         messages: [...past, user],
                         ...(req.tools !== 'off' ? { tools: readOnlyTools(req.readDirs, { images }) } : {}),
                         stopWhen: isStepCount(runtime.maxSteps ?? DEFAULT_STEPS),
@@ -399,13 +382,13 @@ export class ApiBrain {
             hooks.onExit(Date.now());
             await new Promise((r) => out.end(r));
             // 没配凭证的那轮连请求都没发:不进历史
-            if (auth || this.endpoint)
+            if (line || this.endpoint)
                 await appendFile(files.history, `${JSON.stringify(record)}\n`).catch(() => { });
             const logText = await readFile(files.log, 'utf8').catch(() => '');
             const transcript = parseTranscript(logText, parseEventLine);
             const tools = toolCalls(logText, parseEventLine).slice(0, 200);
             return { transcript: { ...transcript, final: transcript.final ?? final }, tools, warnings };
         };
-        return { warm: false, text: () => reader.text(), done: go() };
+        return { text: () => reader.text(), done: go() };
     }
 }

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;