oh-my-agent-web 0.2.0 → 0.4.0

package/dist/server/session/settings.js

@@ -0,0 +1,367 @@
+/**
+ * 客户端设置（ADR-0020 §P1）：`<dataDir>/settings.json`。
+ *
+ * 与 ADR-0005 的索引同一套纪律：**原子写、坏文件不致命、可重建**（重建 = 回默认值）。
+ * 归一化放在纯函数里（`normalizeQuickPhrases`），因为「用户能贴进来什么」永远想不到 ——
+ * 单条超长、重复、空白、几百条，都必须在上盘前收敛。
+ */
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+export const SETTINGS_FILE = "settings.json";
+export const SETTINGS_VERSION = 1;
+/** 与 ADR-0020 对齐的上限 */
+export const MAX_QUICK_PHRASES = 30;
+export const MAX_QUICK_PHRASE_CHARS = 200;
+export const DEFAULT_QUICK_PHRASES = [
+    "继续",
+    "总结一下",
+    "详细解释一下",
+    "检查并修复问题",
+    "补充测试覆盖",
+    "提交并跑测试",
+];
+/**
+ * 「想想」参数上下限。
+ * 条数上限跟 `MAX_ACTIONS`（5）对齐：再多也只会被截掉，界面就别给出会落空的选择。
+ * 超时给到 3 分钟：慢模型 + 长上下文时 20 秒确实会不够。
+ */
+export const MIN_THINK_COUNT = 1;
+export const MAX_THINK_COUNT = 5;
+export const DEFAULT_THINK_COUNT = 5;
+export const MIN_THINK_TIMEOUT_SEC = 5;
+export const MAX_THINK_TIMEOUT_SEC = 180;
+export const DEFAULT_THINK_TIMEOUT_SEC = 20;
+export const MAX_TEMPLATES = 40;
+export const MAX_TEMPLATE_NAME_CHARS = 24;
+export const MAX_TEMPLATE_DESC_CHARS = 60;
+export const MAX_TEMPLATE_TEXT_CHARS = 2000;
+/**
+ * 默认模板库（P5）：都是「开箱即用、点一下就填进输入框」的工作流提示词。
+ * 图标用 emoji，避免为一个图标位引入图标库（依赖预算）。
+ */
+export const DEFAULT_TEMPLATES = [
+    {
+        id: "t-spec",
+        icon: "🏗",
+        name: "规格落地",
+        description: "按规格测试优先实现",
+        text: "按这份规格实现：先写失败的测试，再实现到测试通过。遇到规格里有歧义的地方先问我，别自己猜。",
+    },
+    {
+        id: "t-review",
+        icon: "🧹",
+        name: "代码审查",
+        description: "对照规格与标准审查 diff",
+        text: "审查当前改动：对照规格与仓库既有约定，指出行为差异、边界条件遗漏、以及可以删掉的代码。按严重程度排序。",
+    },
+    {
+        id: "t-map",
+        icon: "🗺",
+        name: "大任务地图",
+        description: "把大工程画成决策地图",
+        text: "把这个大任务拆成决策地图：先列出必须现在决定的选择点、各自代价，再给一条最短可交付路径。",
+    },
+    {
+        id: "t-proto",
+        icon: "⚗️",
+        name: "快速原型",
+        description: "用一次性代码验证设计假设",
+        text: "用一次性原型验证这个设计假设：给出最小可运行代码、要观察的指标，以及结论（继续 / 换方案）。",
+    },
+    {
+        id: "t-research",
+        icon: "📚",
+        name: "有据调研",
+        description: "读一手来源给出带引用的答案",
+        text: "调研这个问题：只读一手来源（官方文档 / 源码 / 规范），给出带链接的结论，不确定的地方明确标注。",
+    },
+    {
+        id: "t-arch",
+        icon: "🏛",
+        name: "架构体检",
+        description: "找出值得重构的模块",
+        text: "体检这个项目的架构：找出耦合过紧、职责过载的模块，按「收益 / 风险」排序给重构建议。",
+    },
+    {
+        id: "t-debug",
+        icon: "🐛",
+        name: "系统化排错",
+        description: "从可复现的失败开始诊断",
+        text: "系统化排错：先给我一条能稳定复现的命令，再二分定位。不要在没有复现之前猜原因。",
+    },
+    {
+        id: "t-conflict",
+        icon: "🔀",
+        name: "解决合并冲突",
+        description: "逐个 hunk 完成合并/变基",
+        text: "解决合并冲突：逐个 hunk 看两侧意图，保留两边语义，冲突解决后跑一遍测试并说明每处取舍。",
+    },
+    {
+        id: "t-ask",
+        icon: "🔍",
+        name: "需求拷问",
+        description: "动手前盘问对齐想法",
+        text: "动手之前先拷问我：把需求里模糊的地方列成问题（最多 5 个），每个给出你倾向的默认答案。",
+    },
+    {
+        id: "t-handoff",
+        icon: "🤝",
+        name: "交接",
+        description: "把长会话写成交接文档",
+        text: "把这次会话整理成交接文档：已完成 / 未完成 / 关键约束 / 下一步第一步，写给完全不了解背景的人。",
+    },
+    {
+        id: "t-plain",
+        icon: "💬",
+        name: "说人话",
+        description: "用大白话重讲刚才的解释",
+        text: "用大白话重讲一遍，把术语替换成日常类比，不超过 10 行。",
+    },
+    {
+        id: "t-tdd",
+        icon: "🧪",
+        name: "测试驱动",
+        description: "红-绿-重构的规则",
+        text: "用测试驱动：先写一个失败的测试并让它跑给我看，再实现到绿，最后重构。每一步都要有命令输出。",
+    },
+];
+export const MAX_DEFAULT_MODELS = 200;
+/** 纯函数：归一化「项目默认模型」——只收绝对路径键与非空模型 id，超出上限就截断 */
+export function normalizeDefaultModels(input) {
+    const out = {};
+    if (typeof input !== "object" || input === null)
+        return out;
+    for (const [key, value] of Object.entries(input)) {
+        if (!key.startsWith("/"))
+            continue;
+        if (typeof value !== "string")
+            continue;
+        const modelId = value.trim();
+        // 必须是 `provider/model`：只写一半的话服务端没法切
+        if (modelId === "" || !modelId.includes("/"))
+            continue;
+        out[key] = modelId;
+        if (Object.keys(out).length >= MAX_DEFAULT_MODELS)
+            break;
+    }
+    return out;
+}
+export const MAX_PROJECT_PREFS = 500;
+export const MAX_ALIAS_CHARS = 40;
+/** 纯函数：归一化项目偏好 —— 只保留绝对路径、去重、上限、别名裁剪 */
+export function normalizeProjectPrefs(input) {
+    const empty = { order: [], pinned: [], aliases: {} };
+    if (typeof input !== "object" || input === null)
+        return empty;
+    const record = input;
+    const paths = (value) => {
+        if (!Array.isArray(value))
+            return [];
+        const seen = new Set();
+        const out = [];
+        for (const item of value) {
+            if (typeof item !== "string")
+                continue;
+            const path = item.trim();
+            if (!path.startsWith("/") || seen.has(path))
+                continue;
+            seen.add(path);
+            out.push(path);
+            if (out.length >= MAX_PROJECT_PREFS)
+                break;
+        }
+        return out;
+    };
+    const aliases = {};
+    if (typeof record.aliases === "object" && record.aliases !== null) {
+        for (const [key, value] of Object.entries(record.aliases)) {
+            if (!key.startsWith("/") || typeof value !== "string")
+                continue;
+            const name = value.trim().slice(0, MAX_ALIAS_CHARS);
+            if (name !== "")
+                aliases[key] = name;
+        }
+    }
+    return { order: paths(record.order), pinned: paths(record.pinned), aliases };
+}
+/** 纯函数：会话偏好的归一化（只保留非空字符串，上限 2000 条；改名不在这里） */
+export function normalizeSessionPrefs(input) {
+    const empty = { pinned: [], archived: [] };
+    if (typeof input !== "object" || input === null)
+        return empty;
+    const record = input;
+    const ids = (value) => Array.isArray(value)
+        ? [...new Set(value.filter((item) => typeof item === "string" && item.trim() !== ""))].slice(0, 2000)
+        : [];
+    // 旧 settings.json 里可能的 titles 直接忽略（改名的事实源是 pi 的会话文件）
+    return { pinned: ids(record.pinned), archived: ids(record.archived) };
+}
+export function defaultSettings() {
+    return {
+        quickPhrases: [...DEFAULT_QUICK_PHRASES],
+        quickPhrasesEnabled: true,
+        templates: DEFAULT_TEMPLATES.map((template) => ({ ...template })),
+        projectPrefs: { order: [], pinned: [], aliases: {} },
+        sessionPrefs: { pinned: [], archived: [] },
+        defaultModels: {},
+        thinkCount: DEFAULT_THINK_COUNT,
+        thinkTimeoutSec: DEFAULT_THINK_TIMEOUT_SEC,
+    };
+}
+/**
+ * 纯函数：规范化快捷短语列表 —— 去空白、限制单条长度、去重、限制条数。
+ * 顺序保持用户给的原样（拖拽排序是后话，见 ADR-0020）。
+ */
+export function normalizeQuickPhrases(input) {
+    if (!Array.isArray(input))
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const item of input) {
+        if (typeof item !== "string")
+            continue;
+        const text = item.replace(/\s+/g, " ").trim();
+        if (text === "")
+            continue;
+        const clipped = text.length > MAX_QUICK_PHRASE_CHARS ? text.slice(0, MAX_QUICK_PHRASE_CHARS) : text;
+        if (seen.has(clipped))
+            continue;
+        seen.add(clipped);
+        out.push(clipped);
+        if (out.length >= MAX_QUICK_PHRASES)
+            break;
+    }
+    return out;
+}
+/**
+ * 纯函数：规范化模板列表 —— 每项必须像模板，字段裁剪长度、id 去重、条数上限。
+ * 顺序保持用户给的原样（用户自己拖过的顺序不该被服务器重排）。
+ */
+export function normalizeTemplates(input) {
+    if (!Array.isArray(input))
+        return [];
+    const seen = new Set();
+    const out = [];
+    for (const item of input) {
+        if (typeof item !== "object" || item === null)
+            continue;
+        const record = item;
+        const name = typeof record.name === "string" ? record.name.replace(/\s+/g, " ").trim().slice(0, MAX_TEMPLATE_NAME_CHARS) : "";
+        const text = typeof record.text === "string" ? record.text.trim().slice(0, MAX_TEMPLATE_TEXT_CHARS) : "";
+        if (name === "" || text === "")
+            continue; // 名字和正文是硬要求
+        const id = typeof record.id === "string" && record.id.trim() !== "" ? record.id.trim() : `t-${out.length + 1}-${name}`;
+        if (seen.has(id))
+            continue;
+        seen.add(id);
+        out.push({
+            id,
+            name,
+            description: typeof record.description === "string"
+                ? record.description.replace(/\s+/g, " ").trim().slice(0, MAX_TEMPLATE_DESC_CHARS)
+                : "",
+            icon: typeof record.icon === "string" ? ([...record.icon][0] ?? "✳️") : "✳️",
+            text,
+            // 软删除标记：只有明确 true 才带上，缺省即显示
+            ...(record.hidden === true ? { hidden: true } : {}),
+        });
+        if (out.length >= MAX_TEMPLATES)
+            break;
+    }
+    return out;
+}
+/** 纯函数：把一个数字收敛到 [min, max]；不是有限数就用默认值（坏值不抛） */
+export function normalizeInt(input, min, max, fallback) {
+    const value = typeof input === "number" ? input : typeof input === "string" ? Number(input.trim()) : Number.NaN;
+    if (!Number.isFinite(value))
+        return fallback;
+    return Math.min(max, Math.max(min, Math.round(value)));
+}
+/** 纯函数：把外来的部分设置合并进现有设置（坏值一律忽略，不抛） */
+export function mergeSettings(current, patch) {
+    if (typeof patch !== "object" || patch === null)
+        return current;
+    const record = patch;
+    const next = { ...current };
+    if ("quickPhrases" in record)
+        next.quickPhrases = normalizeQuickPhrases(record.quickPhrases);
+    if (typeof record.quickPhrasesEnabled === "boolean")
+        next.quickPhrasesEnabled = record.quickPhrasesEnabled;
+    // templates 传 null = 「恢复默认模板」（显式手势，不当成坏值忽略）
+    if (record.templates === null)
+        next.templates = DEFAULT_TEMPLATES.map((template) => ({ ...template }));
+    else if ("templates" in record)
+        next.templates = normalizeTemplates(record.templates);
+    if ("projectPrefs" in record)
+        next.projectPrefs = normalizeProjectPrefs(record.projectPrefs);
+    if ("sessionPrefs" in record)
+        next.sessionPrefs = normalizeSessionPrefs(record.sessionPrefs);
+    if ("defaultModels" in record)
+        next.defaultModels = normalizeDefaultModels(record.defaultModels);
+    if ("thinkCount" in record)
+        next.thinkCount = normalizeInt(record.thinkCount, MIN_THINK_COUNT, MAX_THINK_COUNT, DEFAULT_THINK_COUNT);
+    if ("thinkTimeoutSec" in record)
+        next.thinkTimeoutSec = normalizeInt(record.thinkTimeoutSec, MIN_THINK_TIMEOUT_SEC, MAX_THINK_TIMEOUT_SEC, DEFAULT_THINK_TIMEOUT_SEC);
+    return next;
+}
+/** 纯函数：解析设置文件；坏内容/缺字段回默认值 */
+export function parseSettings(text) {
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return defaultSettings();
+    }
+    return mergeSettings(defaultSettings(), parsed);
+}
+export function settingsPath(dataDir) {
+    return join(dataDir, SETTINGS_FILE);
+}
+export function createFileSettingsStore(dataDir) {
+    return {
+        async load() {
+            try {
+                return parseSettings(await readFile(settingsPath(dataDir), "utf8"));
+            }
+            catch {
+                return defaultSettings(); // 文件不存在/读不了 = 用默认值
+            }
+        },
+        async save(settings) {
+            const target = settingsPath(dataDir);
+            await mkdir(dirname(target), { recursive: true });
+            const temporary = `${target}.tmp`;
+            const payload = { v: SETTINGS_VERSION, ...settings };
+            await writeFile(temporary, `${JSON.stringify(payload, null, "\t")}\n`, "utf8");
+            await rename(temporary, target); // 原子替换
+        },
+    };
+}
+/** 内存版（单测 / 不落盘） */
+export function createMemorySettingsStore(seed = defaultSettings()) {
+    let current = { ...seed };
+    return {
+        async load() {
+            return { ...current };
+        },
+        async save(settings) {
+            current = { ...settings };
+        },
+    };
+}
+/**
+ * 把一次设置改动落到 state + 盘上（runtime 侧的粘合，从 runtime 拆出以守住 400 行护栏）。
+ * 写盘失败只回调警告：内存里的设置仍然生效（下次启动才会回到旧值）。
+ */
+export async function applySettingsPatch(input) {
+    const next = mergeSettings(input.state.settings, input.patch);
+    input.state.settings = next;
+    try {
+        await input.store?.save(next);
+    }
+    catch (error) {
+        input.onError(`保存设置失败：${error instanceof Error ? error.message : String(error)}`);
+    }
+    return next;
+}

package/dist/server/session/snapshot-for.js

@@ -0,0 +1,7 @@
+import { buildSnapshot } from "../snapshot/state.js";
+export function createSnapshotFor(deps) {
+    const { state, clientView, now } = deps;
+    return (clientId) => buildSnapshot(state, undefined, clientView.activeFor(clientId, state.activeId), {
+        includeProjects: clientView.needsProjects(clientId, state.piProjectsVersion, now()),
+    });
+}

package/dist/server/session/stats-refresher.js

@@ -0,0 +1,50 @@
+import { emptyStats, readSessionStats } from "./session-stats.js";
+export function createStatsRefresher(options) {
+    /** 写回：**按读的时候那个会话写**，不能在回来时再用 state.activeId（期间可能已经切走了） */
+    const apply = (stats, conversationId) => {
+        const { state } = options;
+        // 会话级缓存：别的标签页看自己的会话时不会读到别人那份
+        state.statsByConversation[conversationId] = stats;
+        // 面板只显示「当前会话」的数字：切走了就别把上一条的统计糊到新会话上
+        if (state.activeId === conversationId)
+            state.sessionStats = stats;
+    };
+    /**
+     * 读不到统计（新会话还没落盘 / 刚建空文件 / 读失败）：把面板**清零**。
+     * 以前是 `return` 走人 —— 于是上一个会话的 token 数就赖在那儿，新建的会话看着「有记录」。
+     */
+    const clear = (conversationId) => {
+        const { state } = options;
+        const zero = emptyStats();
+        state.statsByConversation[conversationId] = zero;
+        if (state.activeId === conversationId)
+            state.sessionStats = { ...zero };
+    };
+    return async () => {
+        const { state } = options;
+        const id = state.activeId;
+        if (!id)
+            return;
+        // 引擎自带统计优先（dsh）：它知道自己日志里的四桶用量
+        const fromEngine = options.statsOf ? await options.statsOf(id).catch(() => null) : null;
+        if (fromEngine) {
+            apply(fromEngine, id);
+            options.onChanged();
+            return;
+        }
+        // 会话文件路径：opener 登记过的直接用（web 新建的会话也在那儿），没有再扫清单
+        const sessionPath = options.pathOf(id) ??
+            state.piProjects.flatMap((project) => project.sessions).find((session) => session.id === id)
+                ?.sessionPath ??
+            null;
+        const stats = await readSessionStats(sessionPath);
+        // 新会话（文件还没写 / 只有 header）本来就是 0，别把上一个会话的数字留在屏幕上
+        if (!stats) {
+            clear(id);
+            options.onChanged();
+            return;
+        }
+        apply(stats, id);
+        options.onChanged();
+    };
+}

package/dist/server/session/switch-conversation.js

@@ -0,0 +1,86 @@
+/** 耗时上报：`switch <id> 总 123ms · open=100ms models=10ms …`（只进日志，不进对话流） */
+function report(deps, conversationId, began, laps, clientId) {
+    // 带上发起者前缀：多设备时能分清「谁切的」，排查串台全靠它
+    const who = clientId ? ` client=${clientId.slice(0, 8)}` : "";
+    deps.report(`switch ${conversationId.slice(0, 12)}${who} 总 ${Date.now() - began}ms · ${laps.join(" ")}`);
+}
+export function createSwitchConversation(deps) {
+    const { state, clientView } = deps;
+    async function switchTo(conversationId, clientId) {
+        const began = Date.now();
+        const previous = state.activeId;
+        const laps = [];
+        const lap = (label, from) => laps.push(`${label}=${Date.now() - from}ms`);
+        const mine = state.conversations.some((conversation) => conversation.id === conversationId);
+        const fromPi = deps.infoOf(conversationId);
+        // 先校验再动状态：以前 parkPrevious / 清建议 / 改客户端视图都在校验之前，
+        // 点一条已删除的会话会把**当前**会话停泊掉（codex 放开写锁）、建议被清空，
+        // 而界面还停在错误提示上 —— 副作用全白做了。
+        if (!mine && !fromPi) {
+            return { ok: false, error: { code: "session.not_found", message: `会话不存在：${conversationId}` } };
+        }
+        if (previous && previous !== conversationId) {
+            deps.parkPrevious(previous);
+            // 建议不跨会话：切走就清空（「想一想」生成的也不保存，下次打开是空的）
+            state.actions = [];
+        }
+        // 每个客户端各记一份视图（互不影响）
+        if (clientId)
+            clientView.setActive(clientId, conversationId);
+        // 统计先换成本会话的缓存（没有就清空）：refreshStats 是异步的，不先换的话
+        // 这一帧快照里还是**上一个会话**的 token 数（新会话看着像"有记录"）。
+        state.sessionStats = state.statsByConversation[conversationId] ?? null;
+        if (!mine && fromPi) {
+            if (state.activeId !== conversationId || !state.messages[conversationId]) {
+                const tOpen = Date.now();
+                const messages = await deps.open(conversationId, (force) => deps.refreshSessions(force));
+                lap("open", tOpen);
+                if (messages === null) {
+                    return { ok: false, error: { code: "session.open_failed", message: `打开会话失败：${conversationId}` } };
+                }
+                state.messages[conversationId] = messages;
+                const tModels = Date.now();
+                await deps.refreshModels(conversationId);
+                lap("models", tModels);
+                const tThinking = Date.now();
+                await deps.refreshThinking(conversationId);
+                lap("thinking", tThinking);
+                state.activeId = conversationId;
+                state.files = { root: fromPi.workspace, treeVersion: (state.files?.treeVersion ?? 0) + 1 };
+            }
+            const tStats = Date.now();
+            deps.refreshStats();
+            lap("stats", tStats);
+            // 无论有没有真的换（已是当前会话也推）：客户端靠这份快照把乐观高亮退掉，
+            // 否则点一下当前会话就变成「正在打开…」卡在那里 —— 看着就是「点了没反应」。
+            deps.pushSnapshot();
+            report(deps, conversationId, began, laps, clientId);
+            return { ok: true };
+        }
+        if (state.activeId !== conversationId) {
+            state.activeId = conversationId;
+            // 自建会话也要给出文件根，否则文件树一直是空的
+            const workspace = state.conversations.find((item) => item.id === conversationId)?.workspace;
+            if (workspace && state.files?.root !== workspace) {
+                state.files = { root: workspace, treeVersion: (state.files?.treeVersion ?? 0) + 1 };
+            }
+            // 模型选择器是全局一份，切会话必须把「这个会话当前用哪个模型」读回来，
+            // 否则会一直显示上一个会话的模型（看着就像「选的模型没生效」）。
+            const tModels2 = Date.now();
+            await deps.refreshModels(conversationId);
+            lap("models", tModels2);
+            // 思考强度也是「每个会话一份」：自建会话同样要读回来，否则切来切去显示的是上一个会话的
+            const tThinking2 = Date.now();
+            await deps.refreshThinking(conversationId);
+            lap("thinking", tThinking2);
+        }
+        const tStats2 = Date.now();
+        deps.refreshStats();
+        lap("stats", tStats2);
+        // 同一个理由：已经是当前会话也要推一份，客户端才知道「切到了」。
+        deps.pushSnapshot();
+        report(deps, conversationId, began, laps, clientId);
+        return { ok: true };
+    }
+    return switchTo;
+}

package/dist/server/session/throttle.js

@@ -0,0 +1,14 @@
+/**
+ * 简单节流（thinking 增量推帧用）：窗口内只执行一次。
+ * 抽成独立模块只是为了 runtime.ts 守住 400 行，逻辑本身没什么特别。
+ */
+export function createThrottle(windowMs, run) {
+    let last = 0;
+    return () => {
+        const now = Date.now();
+        if (now - last < windowMs)
+            return;
+        last = now;
+        run();
+    };
+}

package/dist/server/session/turn-events.js

@@ -0,0 +1,126 @@
+import { appendError, appendText, appendThinking, finishTool, startTool } from "../snapshot/messages.js";
+import { scheduledCost } from "../util/pricing-index.js";
+/** 思考计时：messageId → 这一段思考的起点（跨事件累计，最后落成 message.thinkingMs） */
+const thinkingSince = new Map();
+/**
+ * 组装「事件 → 状态」的上下文（从 runtime 抽出来，省下十来行装配代码）。
+ * runtime 只提供三件事：原始文本累积、事件出口、回合收尾。
+ */
+export function createTurnContext(options) {
+    return {
+        state: options.state,
+        now: options.now,
+        pushSnapshot: options.pushSnapshot,
+        emitEvent: options.emitEvent,
+        notice: options.notice,
+        onThinkingDelta: options.onThinkingDelta,
+        onTextDelta: options.appendRawText,
+        onTurnEnd: options.finish,
+    };
+}
+export function applyEngineEvent(context, input) {
+    const { conversationId, messageId, event } = input;
+    const { state } = context;
+    const patch = (change) => {
+        const list = state.messages[conversationId] ?? [];
+        state.messages[conversationId] = list.map((message) => (message.id === messageId ? change(message) : message));
+    };
+    /** 结束这一段思考计时，把毫秒累到消息上（thinkingMs） */
+    const closeThinking = () => {
+        const since = thinkingSince.get(messageId);
+        if (since === undefined)
+            return;
+        thinkingSince.delete(messageId);
+        const span = Math.max(0, context.now() - since);
+        if (span <= 0)
+            return;
+        patch((message) => ({ ...message, thinkingMs: (message.thinkingMs ?? 0) + span }));
+    };
+    if (event.type !== "thinking_delta")
+        closeThinking();
+    switch (event.type) {
+        case "text_delta": {
+            const visible = context.onTextDelta(event.text, conversationId);
+            if (visible === "")
+                return; // 抠住了（可能在写标记）
+            patch((message) => appendText(message, visible));
+            if (conversationId === state.activeId)
+                state.running.streamingText += visible;
+            context.emitEvent({ type: "event", event: "message_delta", conversationId, messageId, text: visible });
+            return;
+        }
+        case "thinking_delta": {
+            if (!thinkingSince.has(messageId))
+                thinkingSince.set(messageId, context.now());
+            patch((message) => appendThinking(message, event.text));
+            context.onThinkingDelta?.(conversationId);
+            return;
+        }
+        case "model": {
+            // 每条回复记下自己用的模型（历史/对照时不受「当前选择」影响）
+            patch((message) => ({ ...message, model: event.model }));
+            return;
+        }
+        case "usage": {
+            // 过程值不算（final:false）：同一轮里每调一次模型都会有一份最终值，
+            // 全部**累加**才是这一轮的真实开销 —— 以前是覆盖，只剩最后一次调用的数字。
+            if (event.final === false)
+                return;
+            patch((message) => {
+                const previous = message.usage;
+                // 分时价格（ADR-0026 D 期）：模型配了时段表就按「这次调用发生的时刻」算钱，
+                // 引擎给的 cost 只是兜底（厂商的分时价 pi 根本不知道，混着算只会更错）。
+                // 用增量而不是总额：一轮里跨过时段边界也能各算各的。
+                const scheduled = scheduledCost(message.model ?? state.model, { input: event.input, output: event.output, cacheRead: event.cacheRead, cacheWrite: event.cacheWrite }, context.now());
+                const delta = scheduled ?? event.cost;
+                // 只有真的拿到过价格才给：拿不到就别编一个 0 出来
+                const cost = previous?.cost === undefined && delta === undefined ? undefined : (previous?.cost ?? 0) + (delta ?? 0);
+                return {
+                    ...message,
+                    usage: {
+                        input: (previous?.input ?? 0) + event.input,
+                        output: (previous?.output ?? 0) + event.output,
+                        cacheRead: (previous?.cacheRead ?? 0) + event.cacheRead,
+                        cacheWrite: (previous?.cacheWrite ?? 0) + event.cacheWrite,
+                        ...(cost === undefined ? {} : { cost }),
+                    },
+                };
+            });
+            return;
+        }
+        case "tool_start": {
+            patch((message) => startTool(message, {
+                toolCallId: event.toolCallId,
+                name: event.name,
+                argsSummary: event.argsSummary,
+                argsFull: event.argsFull,
+                startedAt: context.now(),
+            }));
+            state.running.activeTool = { name: event.name, argsSummary: event.argsSummary, startedAt: context.now() };
+            context.pushSnapshot();
+            return;
+        }
+        case "tool_end": {
+            patch((message) => finishTool(message, {
+                toolCallId: event.toolCallId,
+                status: event.status,
+                output: event.output,
+                endedAt: context.now(),
+                ...(event.exitCode === undefined ? {} : { exitCode: event.exitCode }),
+            }));
+            state.running.activeTool = null;
+            context.pushSnapshot();
+            return;
+        }
+        case "error": {
+            patch((message) => appendError(message, event.code, event.message));
+            state.running.status = "error";
+            context.notice(`${event.code}: ${event.message}`, "error");
+            return;
+        }
+        case "turn_end": {
+            context.onTurnEnd(conversationId, event.reason);
+            return;
+        }
+    }
+}