cotutor 0.3.0 → 0.4.0

package/dist/brain/cli/adapters.js

@@ -1,91 +0,0 @@
-/**
- * 适配器注册表:运行时写了 `cli` 就按它找,没写按 run[0] 的文件名。
- * 都对不上(测试的假 CLI 是 `node …_fake-cli.ts`、自家套的壳脚本没写 cli)就按通用的 stream-json 读,
- * 只复用流协议与 Qwen 的工具参数,不设置 Qwen 的运行环境。
- */
-import { basename } from 'node:path';
-import { POLICY_DEFAULTS, fillRuntime } from "../../schema/index.js";
-import { parseStreamJson, streamJsonUserMessage } from "./stream-json.js";
-import { qwen } from "./qwen.js";
-export { textsOf, toolsOf } from "./types.js";
-/** 登记在这里的才认;接一个新 CLI 加一行 */
-export const ADAPTERS = [qwen];
-/** 自定义壳脚本与测试进程的 stream-json 协议,不准备 Qwen 的家目录与认证。 */
-export const STREAM_JSON = {
-    name: 'stream-json',
-    parse: parseStreamJson,
-    stdinMessage: streamJsonUserMessage,
-    toolList: qwen.toolList,
-    toolArgs: qwen.toolArgs,
-    toolKind: qwen.toolKind,
-    env: (env) => env,
-    runtimes: () => ({}),
-};
-/** 历史对话里的工具名仍要能展示读过的文件,不用于启动旧 CLI。 */
-const LEGACY_TOOL_KINDS = { Read: 'read', Bash: 'shell', Grep: 'search', Glob: 'search', Edit: 'edit', Write: 'edit', NotebookEdit: 'edit', MultiEdit: 'edit', Skill: 'skill' };
-/** 运行时的 CLI 名:cli 字段,或 run[0] 的文件名 */
-export function runtimeCli(runtime) {
-    return runtime.cli ?? basename(runtime.run[0] ?? '');
-}
-export function adapterNamed(name) {
-    return ADAPTERS.find((a) => a.name === name) ?? null;
-}
-/** 旧配置仍可读取,但退役的运行器不能通过通用协议兜底启动。 */
-export function runtimeIssue(runtime) {
-    const retired = [runtime.cli, basename(runtime.run[0] ?? ''), basename(runtime.resume?.[0] ?? '')].some((name) => name && /^claude(?:\.exe|\.cmd)?$/i.test(name));
-    return retired ? 'Claude CLI 已移除;先 cotutor upgrade --config 补齐出厂运行时,把 runtimes.default 和 tutors.*.runtime 改为 api 或 api-flash(应用直连百炼;用 Qwen Code 就改为 qwen 或 qwen-flash),再删除旧运行时条目' : null;
-}
-export function adapterFor(runtime) {
-    const issue = runtimeIssue(runtime);
-    if (issue)
-        throw new Error(issue);
-    return adapterNamed(runtimeCli(runtime)) ?? STREAM_JSON;
-}
-/** 工具名属于哪一类:问遍登记的适配器(各家工具名不重),都不认就是 other。老数据只存了名字,也能认 */
-export function toolKind(name) {
-    for (const a of ADAPTERS) {
-        const k = a.toolKind(name);
-        if (k !== 'other')
-            return k;
-    }
-    return LEGACY_TOOL_KINDS[name] ?? 'other';
-}
-/** 模板管得了这轮带不带工具吗:用了 `{tools}` 或 `{toolArgs}`。管不了的,应用也就不替它省掉上下文包里只有工具才用得上的路径 */
-export function controlsTools(runtime) {
-    return [...runtime.run, ...runtime.resume].some((a) => a.includes('{tools}') || a === '{toolArgs}');
-}
-/** 出厂运行时:各适配器的模板合在一起(default 由 skeleton 定) */
-export function factoryRuntimes() {
-    return Object.assign({}, ...ADAPTERS.map((a) => a.runtimes()));
-}
-/**
- * 填模板:独占一个参数的 `{toolArgs}` 换成适配器给的几个参数(可以是零个),`{tools}` 换成适配器的工具名单,其余占位照 schema 的 fillRuntime。
- */
-export function fillArgs(adapter, argv, vars) {
-    const set = vars.tools ?? 'on';
-    const spread = argv.flatMap((a) => (a === '{toolArgs}' ? adapter.toolArgs(set, { readDirs: vars.readDirs ?? [] }) : [a]));
-    return fillRuntime(spread, { ...vars, effort: vars.effort ?? POLICY_DEFAULTS.effort, tools: adapter.toolList(set) });
-}
-/** 起老师进程的环境:基础环境 + 这轮计划里适配器定的变量,再交给适配器补齐认证环境 */
-export function processEnv(plan, base) {
-    const adapter = adapterNamed(plan.cli) ?? STREAM_JSON;
-    return adapter.env({ ...base, ...plan.env });
-}
-/** 按计划里记的适配器名读输出(老数据没有就按 stream-json) */
-export function parserOf(cli) {
-    return (cli ? adapterNamed(cli) : null)?.parse ?? STREAM_JSON.parse;
-}
-/** 按运行时名读输出(落盘的老轮次只记了运行时名;运行时后来删了或改了就按 stream-json)。API 运行时的日志不归这里读,见 src/brain/index.ts 的 logParser */
-export function parserForRuntime(runtimes, name) {
-    const r = name && name !== 'default' ? runtimes[name] : undefined;
-    return r && typeof r === 'object' && Array.isArray(r.run) ? (adapterNamed(runtimeCli(r)) ?? STREAM_JSON).parse : STREAM_JSON.parse;
-}
-/** 起进程前让这个 CLI 的适配器备好 workspace 里的机器文件(qwen 的隔离家目录);没有这一步的 CLI 什么都不做 */
-export async function prepareCli(cli, root) {
-    await adapterNamed(cli)?.prepare?.(root);
-}
-/** 进程起来报的工具表里,不该有的那几样(适配器不核对就是空) */
-export function unexpectedTools(cli, set, tools) {
-    const want = adapterNamed(cli)?.expectedTools?.(set);
-    return want ? tools.filter((t) => !want.includes(t)) : [];
-}

package/dist/brain/cli/qwen.d.ts

@@ -1,11 +0,0 @@
-import type { CliAdapter } from './types.ts';
-/** workspace 里归 qwen 的目录(机器文件,prepare 每次对一遍) */
-export declare const QWEN_DIR = ".cotutor/qwen";
-/** 出厂模型(2026-10-09 五个模型 7 道真题对比:不想时 2–8 秒,讲得准也细;3.7-plus 快但浅,3.8-flash 不想时把盘算写进讲稿——
- * 2026-10-13 英语老师三问没再见到,出厂 qwen-flash 运行时给英语老师) */
-export declare const QWEN_DEFAULT_MODEL = "qwen3.8-max";
-/** 隔离的家里那份 settings.json(没有 key,只写环境变量名) */
-export declare function qwenHomeSettings(): Record<string, unknown>;
-/** 这几份机器文件:绝对路径 → 内容 */
-export declare function qwenFiles(root: string): Record<string, string>;
-export declare const qwen: CliAdapter;

package/dist/brain/cli/qwen.js

@@ -1,141 +0,0 @@
-/**
- * Qwen Code(`qwen`,0.25 起)的适配器。输出读法在 stream-json.ts,运行约定:
- * - **隔离的家**:不用 `--bare`(它不读任何配置、不认 `--core-tools`、自带 read_file / edit / run_shell_command 一套)。
- *   `QWEN_HOME` 指 workspace 的 `.cotutor/qwen/home/`(不改 HOME),里面的 settings.json 由这里生成:模型供应商(key 只写环境变量名)、
- *   关掉它自己的记忆整理(不然一轮跑完在后台用 write_file 写文件)、使用统计、遥测、防休眠。会话落在 `.cotutor/qwen/runtime/`。
- * - **工具**:`{toolArgs}` 展开成 `--core-tools` + `--exclude-tools`;不带 = 工具表为空,只读 = read_file / glob / grep_search。
- *   模板带 `--approval-mode default`:shell、写、读 workspace 外都被拒(`--yolo` 会放行 workspace 外的读)。
- * - **思考量**:没有旗标;按 effort 指一份系统配置(`QWEN_CODE_SYSTEM_SETTINGS_PATH`,`model.reasoningEffort`)。
- * - **key 与端点**:settings.json 只写 `${COTUTOR_QWEN_BASE_URL}` 与环境变量名 `COTUTOR_QWEN_API_KEY`(qwen 读配置时展开);起进程时按 `src/shared/qianwen.ts`
- *   定走 Token Plan 还是百炼按量,把这两个填进子进程的环境,不落盘。出厂的几个模型 Token Plan 都有,有它的 key 就走它。
- * - 没有钱数,只报 token;超时(退出码 55)不吐 result;每轮一条 goal_state 事件(读法里不出事件)。
- */
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { dirname, join } from 'node:path';
-import { compatibleBase, qianwenKeys, qianwenLine } from "../../shared/qianwen.js";
-import { parseStreamJson, streamJsonUserMessage } from "./stream-json.js";
-const KINDS = {
-    read_file: 'read',
-    read_many_files: 'read',
-    zoom_image: 'read',
-    list_directory: 'read',
-    run_shell_command: 'shell',
-    glob: 'search',
-    grep_search: 'search',
-    edit: 'edit',
-    write_file: 'edit',
-    notebook_edit: 'edit',
-    skill: 'skill',
-};
-/** 只读那轮给的核心工具(读文件含图片、按名找、按内容找) */
-const READ_TOOLS = ['read_file', 'glob', 'grep_search'];
-/** `--core-tools` 管不到的非核心工具,要一个个排除(0.25 的 system/init 里出现过的;ask_user_question 与计划模式那两个是不加 --bare 时才有的,2026-10-09 真跑里核对出来) */
-const NON_CORE = ['agent', 'skill', 'list_agents', 'task_stop', 'send_message', 'record_artifact', 'get_goal', 'update_goal', 'tool_call', 'tool_search', 'report_findings', 'enter_worktree', 'exit_worktree', 'ask_user_question', 'enter_plan_mode', 'exit_plan_mode'];
-/** workspace 里归 qwen 的目录(机器文件,prepare 每次对一遍) */
-export const QWEN_DIR = '.cotutor/qwen';
-const homeOf = (root) => join(root, QWEN_DIR, 'home');
-const effortFile = (root, level) => join(root, QWEN_DIR, `effort-${level}.json`);
-/** 政策 effort → 模型的思考档:low 不想(孩子在等);qwen3.7 系列只有开关,none 以外都是开 */
-const EFFORT = { low: 'none', medium: 'low', high: 'xhigh' };
-/**
- * 带工具的轮次(作业照片、记账)至少想一点:2026-10-09 真跑,同一道照片题 none 那次 read_file 都没调、请孩子说是哪页;
- * low 那次读了图、认出题目(11 秒)。孩子随口的话不带工具,不想照旧(3–6 秒)
- */
-const levelOf = (effort, tools) => (tools !== 'off' && EFFORT[effort] === 'none' ? 'low' : EFFORT[effort]);
-/** settings.json 里写的占位;qwen 读配置时拿子进程环境展开 */
-const BASE_ENV = 'COTUTOR_QWEN_BASE_URL';
-const KEY_ENV = 'COTUTOR_QWEN_API_KEY';
-const toggle = { thinking: true, toggleOnly: true, disableField: 'enable_thinking' };
-const tiers = { thinking: true, efforts: ['low', 'medium', 'xhigh'], defaultEffort: 'xhigh', disableField: 'reasoning_effort' };
-/** 出厂模型(2026-10-09 五个模型 7 道真题对比:不想时 2–8 秒,讲得准也细;3.7-plus 快但浅,3.8-flash 不想时把盘算写进讲稿——
- * 2026-10-13 英语老师三问没再见到,出厂 qwen-flash 运行时给英语老师) */
-export const QWEN_DEFAULT_MODEL = 'qwen3.8-max';
-/** 千问上能用的几个(Token Plan 与百炼按量都有);运行时模板的 -m 选其中一个 */
-const MODELS = [
-    { id: 'qwen3.7-plus', capabilities: { reasoning: toggle }, generationConfig: { contextWindowSize: 1_000_000, modalities: { image: true } } },
-    { id: 'qwen3.7-max', capabilities: { reasoning: toggle }, generationConfig: { contextWindowSize: 1_000_000 } },
-    { id: 'qwen3.8-flash', capabilities: { reasoning: tiers }, generationConfig: { contextWindowSize: 1_000_000, modalities: { image: true, video: true } } },
-    { id: 'qwen3.8-max', capabilities: { reasoning: tiers }, generationConfig: { contextWindowSize: 1_000_000, modalities: { image: true, video: true } } },
-];
-/** 隔离的家里那份 settings.json(没有 key,只写环境变量名) */
-export function qwenHomeSettings() {
-    return {
-        $version: 4,
-        security: { auth: { selectedType: 'openai' } },
-        model: { name: QWEN_DEFAULT_MODEL },
-        modelProviders: { openai: MODELS.map((m) => ({ ...m, baseUrl: `\${${BASE_ENV}}`, envKey: KEY_ENV })) },
-        memory: { enableManagedAutoMemory: false, enableManagedAutoDream: false },
-        privacy: { usageStatisticsEnabled: false },
-        telemetry: { enabled: false },
-        general: { disableAutoUpdate: true, disableUpdateNag: true, preventSystemSleep: false },
-    };
-}
-/** 这几份机器文件:绝对路径 → 内容 */
-export function qwenFiles(root) {
-    const files = {
-        // 整个目录不进 git:会话记录(runtime/)是对话原文,同 conversations/ 只留本机;其余都是这里每次重新生成的
-        [join(root, QWEN_DIR, '.gitignore')]: '# qwen 的隔离家目录与会话记录(cotutor 生成,对话原文只留本机)\n*\n',
-        [join(homeOf(root), 'settings.json')]: `${JSON.stringify(qwenHomeSettings(), null, 2)}\n`,
-    };
-    for (const level of new Set(Object.values(EFFORT)))
-        files[effortFile(root, level)] = `${JSON.stringify({ $version: 4, model: { reasoningEffort: level } }, null, 2)}\n`;
-    return files;
-}
-/** 别处的设置会盖掉家里选的模型与供应商,起进程时去掉 */
-const FOREIGN = ['OPENAI_API_KEY', 'OPENAI_BASE_URL', 'OPENAI_MODEL', 'QWEN_MODEL'];
-export const qwen = {
-    name: 'qwen',
-    parse: parseStreamJson,
-    stdinMessage: streamJsonUserMessage,
-    // qwen 的带工具只有只读一档(read / on 一样):shell 与写本来就不给
-    toolList: (set) => (set !== 'off' ? READ_TOOLS.join(',') : ''),
-    // --core-tools 是白名单,不带时也要给一个(给空等于不限),再把它排除掉;非核心工具不归 --core-tools 管,总要排除。
-    // 只读那轮把 workspace 根与 vault 加进可读范围:会话 cwd 是老师目录,作业照片(captures/)与教材在它外面,读外面要征得同意——
-    // 消息走 stdin 时它就停在那儿等,一直等到 --max-wall-time(2026-10-09 真跑,开了思考的那次读照片挂住)
-    toolArgs: (set, { readDirs }) => set !== 'off'
-        ? ['--core-tools', READ_TOOLS.join(','), '--exclude-tools', NON_CORE.join(','), ...readDirs.flatMap((d) => ['--include-directories', d])]
-        : ['--core-tools', 'read_file', '--exclude-tools', ['read_file', ...NON_CORE].join(',')],
-    toolKind: (name) => KINDS[name] ?? 'other',
-    expectedTools: (set) => (set !== 'off' ? READ_TOOLS : []),
-    planEnv: ({ root, effort, tools }) => root ? { QWEN_HOME: homeOf(root), QWEN_RUNTIME_DIR: join(root, QWEN_DIR, 'runtime'), QWEN_CODE_SYSTEM_SETTINGS_PATH: effortFile(root, levelOf(effort, tools)) } : {},
-    async prepare(root) {
-        for (const [file, text] of Object.entries(qwenFiles(root))) {
-            if ((await readFile(file, 'utf8').catch(() => null)) === text)
-                continue;
-            await mkdir(dirname(file), { recursive: true });
-            await writeFile(file, text);
-        }
-    },
-    env: (env) => {
-        const out = { ...env, QWEN_USAGE_STATISTICS_ENABLED: 'false', QWEN_CODE_MODELS_DEV: 'off', QWEN_CODE_SUPPRESS_YOLO_WARNING: '1' };
-        for (const k of FOREIGN)
-            delete out[k];
-        const line = qianwenLine(QWEN_DEFAULT_MODEL, qianwenKeys(out));
-        if (line) {
-            out[BASE_ENV] = compatibleBase(line.host);
-            out[KEY_ENV] = line.key;
-        }
-        return out;
-    },
-    check: ({ version, env }) => {
-        const v = /(\d+)\.(\d+)\.(\d+)/.exec(version);
-        const old = !v || Number(v[1]) === 0 && Number(v[2]) < 25;
-        const line = qianwenLine(QWEN_DEFAULT_MODEL, qianwenKeys(env));
-        return [
-            { name: 'version', ok: !old, detail: old ? `qwen ${version || '?'}:要 0.25 起(关工具的旗标、隔离的家、思考量配置都按 0.25 定的)` : `qwen ${version}`, fix: old ? 'qwen update(或 brew upgrade qwen-code)' : undefined },
-            line
-                ? { name: 'key', ok: true, detail: line.plan ? '走千问 Token Plan(QWENCLOUD_TOKEN_PLAN_API_KEY)' : '走百炼按量(DASHSCOPE_API_KEY,或本机 qwen / voxtell 的配置)' }
-                : { name: 'key', ok: false, detail: '千问的 key 一把都拿不到:老师进程起来就会 401', fix: '在起 serve 的 shell 里 export QWENCLOUD_TOKEN_PLAN_API_KEY(Token Plan,sk-sp-)或 DASHSCOPE_API_KEY(百炼按量)' },
-        ];
-    },
-    runtimes: () => {
-        // 消息走 stdin(预热能用;数组旗标 --core-tools 之类会吞掉跟在后面的消息,不进 argv 正好避开);-m 选模型(家里那份 settings.json 列着的);
-        // {systemBody} = 老师正文 + 板书写法,整份换掉 qwen 自己的系统提示;{toolArgs} 由适配器展开;--approval-mode default:shell、写、读 workspace 外都拒
-        // qwen-flash 只差模型(2026-10-13 英语老师出厂走它:Token Plan 上便宜、开口 2.5–4 秒)
-        const of = (model) => {
-            const flags = ['-m', model, '--system-prompt', '{systemBody}', '--input-format', 'stream-json', '--output-format', 'stream-json', '--include-partial-messages', '--approval-mode', 'default', '{toolArgs}', '--max-wall-time', '10m'];
-            return { stdin: 'stream-json', run: ['qwen', ...flags], resume: ['qwen', '--resume', '{session}', ...flags] };
-        };
-        return { qwen: of(QWEN_DEFAULT_MODEL), 'qwen-flash': of('qwen3.8-flash') };
-    },
-};

package/dist/brain/cli/run-plan.d.ts

@@ -1,59 +0,0 @@
-import { streamJsonUserMessage } from './stream-json.ts';
-import type { ToolSet } from './types.ts';
-import { type ConversationIndex, type CotutorConfig, type Policy, type Runtime } from '../../schema/index.ts';
-export interface RunPlan {
-    /** 运行时名(runtimes 里的键) */
-    runtime: string;
-    /** 适配器名(src/brain/cli/;认不出的是 stream-json) */
-    cli: string;
-    /** 这轮带不带工具(模板管不了工具的运行时也照记,只是没用上) */
-    tools: ToolSet;
-    /** 完整命令行,argv[0] 是可执行文件 */
-    argv: string[];
-    /** 这次是 resume 还是新开 */
-    resume: boolean;
-    /** resume 的会话 id */
-    session: string | null;
-    /** 运行时 stdin: "stream-json":要写进 stdin 的那一行(用户消息,带换行);消息不在 argv 里 */
-    stdin?: string;
-    /** 适配器按这轮的计划定的环境变量(qwen 的思考量配置之类);和 argv 一起进预热的比对 */
-    env: Record<string, string>;
-}
-export declare class RuntimeError extends Error {
-}
-export declare function getRuntime(config: CotutorConfig, name?: string): {
-    name: string;
-    runtime: Runtime;
-};
-/** 模板里有没有用到某个占位符(决定要不要去读老师正文)。API 运行时没有模板:系统提示由应用给,算用了 {systemBody} */
-export declare function runtimeUses(runtime: Runtime, placeholder: string): boolean;
-/**
- * 这个运行时把板书写法预载进系统提示了吗:模板用了 {boardFile} / {systemBody},或者(2026-09-19 头一版)写死了 cotutor-board/SKILL.md 的路径。
- * 没有 → 应用在话题第一条注入 <cotutor-board>。
- */
-export declare function boardPreloaded(runtime: Runtime): boolean;
-export declare function planRun(config: CotutorConfig, index: Pick<ConversationIndex, 'session'>, vars: {
-    agent: string;
-    prompt: string;
-    agentBody?: string;
-    systemBody?: string;
-    boardFile?: string;
-    runtime?: string;
-    effort?: Policy['effort'];
-    tools?: ToolSet;
-    root?: string;
-    readDirs?: readonly string[];
-}): RunPlan;
-/** stream-json 输入的一条用户消息(Qwen 的 `--input-format stream-json` 一行一条;别的 CLI 看它的适配器) */
-export declare const stdinMessage: typeof streamJsonUserMessage;
-/**
- * 断流后接着跑的那条消息(policy.stall):resume 同一个会话发给老师。被杀的那段回复只流到了 stdout,没进会话,
- * 所以断在半截的正文(open)原样递回去,让它从断处接着写;应用把 open 拼在这次的收尾正文前面。
- * open 为空 = 这一段一个字没出来,已经做完的工具调用与整段都在会话里,接着把这一轮做完。
- */
-export declare function stallPrompt(open: string): string;
-/**
- * 老师把工具调用写成了正文、停在那里等结果(这轮没给它那个工具,qwen 照自己的格式写出来;板书解析器把那块剥掉了):
- * resume 同一个会话,告诉它不会有结果,接着直接回孩子。那块前面写的话已经进了会话,应用拼在这次的前面
- */
-export declare function toolLeakPrompt(): string;

package/dist/brain/cli/run-plan.js

@@ -1,71 +0,0 @@
-/**
- * 一次运行的命令规划(纯函数):按运行时选 run 还是 resume、填占位符、定 cwd 相对路径。
- * 规则:当天索引里已有会话**且**是同一运行时跑出来的 → resume;否则新开(跨天索引本来就是新的,零点后第一条自然不带 --resume;
- * 换了运行时也新开——不同运行时的会话不混用)。{agentBody} 只给模板里真用到它的运行时读老师正文。
- */
-import { adapterFor, fillArgs } from "./adapters.js";
-import { streamJsonUserMessage } from "./stream-json.js";
-import { POLICY_DEFAULTS, isApiRuntime } from "../../schema/index.js";
-export class RuntimeError extends Error {
-}
-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('、')}`);
-    }
-    return { name: n, runtime: p };
-}
-/** 模板里有没有用到某个占位符(决定要不要去读老师正文)。API 运行时没有模板:系统提示由应用给,算用了 {systemBody} */
-export function runtimeUses(runtime, placeholder) {
-    if (isApiRuntime(runtime))
-        return placeholder === '{systemBody}';
-    return [...runtime.run, ...runtime.resume].some((a) => a.includes(placeholder));
-}
-/**
- * 这个运行时把板书写法预载进系统提示了吗:模板用了 {boardFile} / {systemBody},或者(2026-09-19 头一版)写死了 cotutor-board/SKILL.md 的路径。
- * 没有 → 应用在话题第一条注入 <cotutor-board>。
- */
-export function boardPreloaded(runtime) {
-    return runtimeUses(runtime, '{boardFile}') || runtimeUses(runtime, '{systemBody}') || runtimeUses(runtime, 'cotutor-board/SKILL.md');
-}
-export function planRun(config, index, vars) {
-    const { name, runtime } = getRuntime(config, vars.runtime);
-    if (isApiRuntime(runtime))
-        throw new RuntimeError(`运行时 "${name}" 是 API 运行时,不起命令行(src/brain/api.ts)`);
-    const adapter = adapterFor(runtime);
-    const session = index.session && index.session.runtime === name ? index.session.id : null;
-    const template = session ? runtime.resume : runtime.run;
-    const effort = vars.effort ?? POLICY_DEFAULTS.effort;
-    return {
-        runtime: name,
-        cli: adapter.name,
-        tools: vars.tools ?? 'on',
-        argv: fillArgs(adapter, template, { agent: vars.agent, prompt: vars.prompt, session: session ?? undefined, agentBody: vars.agentBody, systemBody: vars.systemBody, boardFile: vars.boardFile, effort: vars.effort, tools: vars.tools, readDirs: vars.readDirs }),
-        resume: session !== null,
-        session,
-        ...(runtime.stdin ? { stdin: adapter.stdinMessage(vars.prompt) } : {}),
-        env: adapter.planEnv?.({ root: vars.root, effort, tools: vars.tools ?? 'on' }) ?? {},
-    };
-}
-/** stream-json 输入的一条用户消息(Qwen 的 `--input-format stream-json` 一行一条;别的 CLI 看它的适配器) */
-export const stdinMessage = streamJsonUserMessage;
-/**
- * 断流后接着跑的那条消息(policy.stall):resume 同一个会话发给老师。被杀的那段回复只流到了 stdout,没进会话,
- * 所以断在半截的正文(open)原样递回去,让它从断处接着写;应用把 open 拼在这次的收尾正文前面。
- * open 为空 = 这一段一个字没出来,已经做完的工具调用与整段都在会话里,接着把这一轮做完。
- */
-export function stallPrompt(open) {
-    const rule = '不道歉,不提断了,不重复前面的。';
-    return open
-        ? `(应用注)你刚才那段回复传到一半网络断了。孩子那边已经看到、听到的就是下面 <<< 与 >>> 之间这些:\n<<<\n${open}\n>>>\n从断的地方直接接着写,字要接得上;${rule}`
-        : `(应用注)你刚才那段回复网络断了,一个字没传出来。已经做完的工具调用和写完的段都还在,接着把这一轮做完;${rule}`;
-}
-/**
- * 老师把工具调用写成了正文、停在那里等结果(这轮没给它那个工具,qwen 照自己的格式写出来;板书解析器把那块剥掉了):
- * resume 同一个会话,告诉它不会有结果,接着直接回孩子。那块前面写的话已经进了会话,应用拼在这次的前面
- */
-export function toolLeakPrompt() {
-    return '(应用注)你刚才写的工具调用没有执行,孩子也看不到。这一轮不用工具,接着直接回孩子;不提工具,不道歉,不重复前面的。';
-}

package/dist/brain/cli/run.d.ts

@@ -1,35 +0,0 @@
-import { type RunPlan } from './run-plan.ts';
-import type { CliRuntime, CotutorConfig, Policy } from '../../schema/index.ts';
-import type { BrainExecutor, BrainHooks, BrainRequest, BrainRun, WarmKey } from '../index.ts';
-import { type Slot } from './warm.ts';
-export declare class CliBrain implements BrainExecutor {
-    private readonly spares;
-    private readonly workspace;
-    /** 起子进程用的环境(测试注入);缺省 process.env */
-    private readonly env;
-    constructor(opts: {
-        workspace: () => {
-            config: CotutorConfig;
-            root: string;
-        };
-        env?: NodeJS.ProcessEnv;
-        warmIdleMs?: number;
-    });
-    plan(req: BrainRequest): RunPlan;
-    prepare(plan: RunPlan): Promise<void>;
-    canWarm(runtime: CliRuntime): boolean;
-    warm(tutor: string, slot: Slot, plan: RunPlan, key: WarmKey): void;
-    warmed(tutor: string, slot?: Slot): boolean;
-    dropWarm(tutor: string, slot?: Slot): void;
-    close(): void;
-    private processEnv;
-    start(req: BrainRequest, plan: RunPlan, ctx: {
-        tutor: string;
-        key: WarmKey;
-        files: {
-            log: string;
-            err: string;
-        };
-        stall: Policy['stall'];
-    }, hooks: BrainHooks): BrainRun;
-}