@baique/pi-web-sky 0.1.35 → 0.1.37

package/lib/sqlite-db.ts

@@ -0,0 +1,205 @@
+import { DatabaseSync } from "node:sqlite";
+import { homedir } from "os";
+import { join, normalize } from "path";
+
+/** Same semantics as the SDK's getAgentDir — keeps this module SDK-free so
+ *  unit tests can load it without pulling in the whole coding-agent dist. */
+const ENV_AGENT_DIR = "PI_CODING_AGENT_DIR";
+
+export function getAgentDir(): string {
+  const envDir = process.env[ENV_AGENT_DIR];
+  if (envDir) {
+    const expanded = envDir.startsWith("~") ? join(homedir(), envDir.slice(1)) : envDir;
+    return normalize(expanded);
+  }
+  return join(homedir(), ".pi", "agent");
+}
+
+declare global {
+  var __piWebDb: DatabaseSync | undefined;
+}
+
+export const DB_FILE_NAME = "pi-web.db";
+
+/** Absolute path of the single pi-web database (lives next to agent dir). */
+export function dbPath(): string {
+  return join(getAgentDir(), DB_FILE_NAME);
+}
+
+/** Inject a database for tests (e.g. `:memory:`). Overrides the singleton and
+ *  ensures the schema is present so callers can use it immediately. */
+export function setDbForTesting(db: DatabaseSync): void {
+  initSchema(db);
+  globalThis.__piWebDb = db;
+}
+
+/**
+ * Open (once) and return the pi-web database, creating tables on first use.
+ * Stored on globalThis so it survives Next.js hot-reload like the other
+ * singletons in this codebase.
+ */
+export function getDb(): DatabaseSync {
+  if (globalThis.__piWebDb) return globalThis.__piWebDb;
+  const db = new DatabaseSync(dbPath());
+  db.exec("PRAGMA journal_mode = WAL;");
+  db.exec("PRAGMA foreign_keys = ON;");
+  initSchema(db);
+  globalThis.__piWebDb = db;
+  return db;
+}
+
+/** Idempotent DDL — run on every open; `IF NOT EXISTS` keeps it cheap. */
+export function initSchema(db: DatabaseSync): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS tasks (
+      id          TEXT PRIMARY KEY,
+      project_key TEXT NOT NULL,
+      name        TEXT NOT NULL,
+      created     INTEGER NOT NULL,
+      updated     INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_tasks_project ON tasks(project_key);
+
+    CREATE TABLE IF NOT EXISTS session_meta (
+      session_id TEXT PRIMARY KEY,
+      task_id    TEXT,
+      updated    INTEGER NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS idx_meta_task ON session_meta(task_id);
+
+    CREATE TABLE IF NOT EXISTS search_state (
+      session_id TEXT PRIMARY KEY,
+      mtime      TEXT NOT NULL,
+      title      TEXT NOT NULL
+    );
+
+    CREATE VIRTUAL TABLE IF NOT EXISTS session_search USING fts5(
+      session_id UNINDEXED,
+      title,
+      body,
+      tokenize = 'trigram'
+    );
+  `);
+  migrate(db);
+}
+
+/**
+ * 版本化迁移：用 PRAGMA user_version 记录当前 schema 版本。
+ * 老库打开时自动按序补齐缺失的迁移（每个迁移一个事务，成功后推进版本号），
+ * 新库建表后从 v0 一路迁到 SCHEMA_VERSION。重复打开不再执行已完成的迁移。
+ */
+export const SCHEMA_VERSION = 8;
+
+interface Migration {
+  version: number;
+  name: string;
+  /** 单条语句串；每条独立执行，包在同一个事务里。 */
+  statements: string[];
+}
+
+/** 迁移历史（按版本升序）。只允许追加，不允许修改/删除历史项。 */
+const MIGRATIONS: Migration[] = [
+  {
+    version: 1,
+    name: "pinned columns",
+    statements: [
+      "ALTER TABLE tasks ADD COLUMN pinned INTEGER NOT NULL DEFAULT 0;",
+      "ALTER TABLE session_meta ADD COLUMN pinned INTEGER NOT NULL DEFAULT 0;",
+    ],
+  },
+  {
+    version: 2,
+    name: "tasks.sort_order",
+    statements: [
+      "ALTER TABLE tasks ADD COLUMN sort_order INTEGER NOT NULL DEFAULT 0;",
+    ],
+  },
+  {
+    version: 3,
+    name: "session boards",
+    statements: [
+      "CREATE TABLE IF NOT EXISTS boards (\n  id          TEXT PRIMARY KEY,\n  project_key TEXT NOT NULL,\n  name        TEXT NOT NULL,\n  is_system   INTEGER NOT NULL DEFAULT 0,\n  created     INTEGER NOT NULL,\n  updated     INTEGER NOT NULL\n);",
+      "CREATE INDEX IF NOT EXISTS idx_boards_project ON boards(project_key);",
+      "CREATE TABLE IF NOT EXISTS board_nodes (\n  id         TEXT PRIMARY KEY,\n  board_id   TEXT NOT NULL,\n  kind       TEXT NOT NULL,\n  ref_id     TEXT,\n  x          REAL NOT NULL,\n  y          REAL NOT NULL,\n  w          REAL NOT NULL DEFAULT 0,\n  h          REAL NOT NULL DEFAULT 0,\n  expanded   INTEGER NOT NULL DEFAULT 0,\n  props      TEXT NOT NULL DEFAULT '{}',\n  created    INTEGER NOT NULL,\n  updated    INTEGER NOT NULL\n);",
+      "CREATE INDEX IF NOT EXISTS idx_board_nodes_board ON board_nodes(board_id);",
+      "CREATE TABLE IF NOT EXISTS board_edges (\n  id       TEXT PRIMARY KEY,\n  board_id TEXT NOT NULL,\n  from_id  TEXT NOT NULL,\n  to_id    TEXT NOT NULL,\n  label    TEXT,\n  color    TEXT,\n  dashed   INTEGER NOT NULL DEFAULT 0,\n  created  INTEGER NOT NULL,\n  updated  INTEGER NOT NULL\n);",
+      "CREATE INDEX IF NOT EXISTS idx_board_edges_board ON board_edges(board_id);",
+      "CREATE TABLE IF NOT EXISTS board_view (\n  board_id   TEXT PRIMARY KEY,\n  camera_x   REAL NOT NULL DEFAULT 0,\n  camera_y   REAL NOT NULL DEFAULT 0,\n  camera_z   REAL NOT NULL DEFAULT 1,\n  updated    INTEGER NOT NULL\n);",
+    ],
+  },
+  {
+    version: 4,
+    name: "boards.sort_order",
+    statements: [
+      "ALTER TABLE boards ADD COLUMN sort_order INTEGER NOT NULL DEFAULT 0;",
+    ],
+  },
+  {
+    version: 5,
+    name: "boards.task_id",
+    statements: [
+      "ALTER TABLE boards ADD COLUMN task_id TEXT NULL;",
+      "CREATE INDEX IF NOT EXISTS idx_boards_task ON boards(task_id);",
+    ],
+  },
+  {
+    version: 6,
+    name: "boards.task_id unique (防并发重复创建任务看板)",
+    statements: [
+      // 任务看板 id = 任务 id，task_id 必须唯一。SQLite UNIQUE 索引允许多个 NULL，
+      // 手动看板（task_id=NULL）不受影响。并发懒创建时由数据库层拒绝重复插入。
+      "CREATE UNIQUE INDEX IF NOT EXISTS idx_boards_task_unique ON boards(task_id);",
+    ],
+  },
+  {
+    version: 7,
+    name: "task cards",
+    statements: [
+      "CREATE TABLE IF NOT EXISTS task_cards (\n  id            TEXT PRIMARY KEY,\n  board_id      TEXT NOT NULL,\n  project_key   TEXT NOT NULL,\n  number        INTEGER NOT NULL,\n  name          TEXT NOT NULL,\n  description   TEXT NOT NULL DEFAULT '',\n  ready_status  TEXT NOT NULL DEFAULT 'draft',\n  exec_status   TEXT NOT NULL DEFAULT 'not_started',\n  priority      INTEGER NOT NULL DEFAULT 0,\n  due           INTEGER,\n  attachments   TEXT NOT NULL DEFAULT '[]',\n  cwd           TEXT,\n  use_worktree  INTEGER NOT NULL DEFAULT 0,\n  max_retries   INTEGER NOT NULL DEFAULT 3,\n  retry_count   INTEGER NOT NULL DEFAULT 0,\n  session_id    TEXT,\n  created       INTEGER NOT NULL,\n  updated       INTEGER NOT NULL\n);",
+      "CREATE INDEX IF NOT EXISTS idx_task_cards_board ON task_cards(board_id);",
+      "CREATE INDEX IF NOT EXISTS idx_task_cards_project ON task_cards(project_key);",
+      "CREATE UNIQUE INDEX IF NOT EXISTS idx_task_cards_number ON task_cards(project_key, number);",
+      "CREATE INDEX IF NOT EXISTS idx_task_cards_status ON task_cards(ready_status, exec_status);",
+      "CREATE TABLE IF NOT EXISTS task_card_links (\n  id             TEXT PRIMARY KEY,\n  card_id        TEXT NOT NULL,\n  target_card_id TEXT NOT NULL,\n  kind           TEXT NOT NULL,\n  created        INTEGER NOT NULL,\n  UNIQUE(card_id, target_card_id, kind)\n);",
+      "CREATE INDEX IF NOT EXISTS idx_task_links_card ON task_card_links(card_id);",
+      "CREATE TABLE IF NOT EXISTS task_card_questions (\n  id         TEXT PRIMARY KEY,\n  card_id    TEXT NOT NULL,\n  session_id TEXT NOT NULL,\n  question   TEXT NOT NULL,\n  status     TEXT NOT NULL DEFAULT 'pending',\n  answer     TEXT,\n  created    INTEGER NOT NULL,\n  answered   INTEGER\n);",
+      "CREATE INDEX IF NOT EXISTS idx_task_questions_status ON task_card_questions(status);",
+    ],
+  },
+  {
+    version: 8,
+    name: "task_cards.dispatch_token (跨进程派发互斥锁)",
+    statements: [
+      // 多实例（dev + 全局 CLI + 残留服务）共库时，同一张卡可能被多个调度器
+      // 同时捞到并发派发 → 双会话。派发前条件 UPDATE 原子抢 token，谁抢到谁执行。
+      "ALTER TABLE task_cards ADD COLUMN dispatch_token TEXT NULL;",
+    ],
+  },
+];
+
+function migrate(db: DatabaseSync): void {
+  const row = db.prepare("PRAGMA user_version").get() as { user_version: number };
+  let version = row.user_version;
+  for (const m of MIGRATIONS) {
+    if (m.version <= version) continue;
+    db.exec("BEGIN");
+    try {
+      for (const stmt of m.statements) {
+        try {
+          db.exec(stmt);
+        } catch (error) {
+          // 老库在无版本管理时代可能已手动加过列（幂等 ADD COLUMN 路径），
+          // 列已存在时跳过该语句，不阻断整批迁移。
+          const msg = error instanceof Error ? error.message : String(error);
+          if (!/duplicate column name/i.test(msg)) throw error;
+        }
+      }
+      db.exec(`PRAGMA user_version = ${m.version}`);
+      db.exec("COMMIT");
+      version = m.version;
+    } catch (error) {
+      db.exec("ROLLBACK");
+      throw error;
+    }
+  }
+}

package/lib/startup-preferences.test.mjs

@@ -0,0 +1,130 @@
+import assert from "node:assert/strict";
+import { mkdtemp, mkdir, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import test from "node:test";
+import { SettingsManager } from "@earendil-works/pi-coding-agent";
+import { createJiti } from "jiti";
+
+const { persistExplicitStartupPreferences } = await createJiti(import.meta.url)
+  .import("./startup-preferences.ts");
+
+async function withSettings(run) {
+  const root = await mkdtemp(join(tmpdir(), "pi-web-startup-preferences-"));
+  const cwd = join(root, "cwd");
+  const agentDir = join(root, "agent");
+  await mkdir(cwd);
+  await mkdir(agentDir);
+
+  try {
+    const settings = SettingsManager.create(cwd, agentDir);
+    await run({ settings, settingsPath: join(agentDir, "settings.json") });
+  } finally {
+    await rm(root, { recursive: true, force: true });
+  }
+}
+
+test("persists explicit effective model and thinking defaults", async () => {
+  await withSettings(async ({ settings, settingsPath }) => {
+    const result = await persistExplicitStartupPreferences(
+      settings,
+      {
+        model: { provider: "deepseek", modelId: "deepseek-chat" },
+        thinkingLevel: "xhigh",
+      },
+      {
+        model: { provider: "deepseek", modelId: "deepseek-chat" },
+        thinkingLevel: "high",
+        supportsThinking: true,
+      },
+    );
+
+    const saved = JSON.parse(await readFile(settingsPath, "utf8"));
+    assert.deepEqual(
+      {
+        defaultProvider: saved.defaultProvider,
+        defaultModel: saved.defaultModel,
+        defaultThinkingLevel: saved.defaultThinkingLevel,
+      },
+      {
+        defaultProvider: "deepseek",
+        defaultModel: "deepseek-chat",
+        defaultThinkingLevel: "high",
+      },
+    );
+    assert.equal(result.modelDefaultChanged, true);
+  });
+});
+
+test("does not persist implicit scope selections", async () => {
+  await withSettings(async ({ settings }) => {
+    settings.setDefaultModelAndProvider("saved", "saved-model");
+    settings.setDefaultThinkingLevel("medium");
+    await settings.flush();
+
+    const result = await persistExplicitStartupPreferences(
+      settings,
+      {},
+      {
+        model: { provider: "scoped", modelId: "scoped-model" },
+        thinkingLevel: "high",
+        supportsThinking: true,
+      },
+    );
+
+    assert.equal(settings.getDefaultProvider(), "saved");
+    assert.equal(settings.getDefaultModel(), "saved-model");
+    assert.equal(settings.getDefaultThinkingLevel(), "medium");
+    assert.equal(result.modelDefaultChanged, false);
+  });
+});
+
+test("does not persist a model when startup resolved a different model", async () => {
+  await withSettings(async ({ settings }) => {
+    const result = await persistExplicitStartupPreferences(
+      settings,
+      { model: { provider: "requested", modelId: "requested-model" } },
+      {
+        model: { provider: "fallback", modelId: "fallback-model" },
+        thinkingLevel: "off",
+        supportsThinking: false,
+      },
+    );
+
+    assert.equal(settings.getDefaultProvider(), undefined);
+    assert.equal(settings.getDefaultModel(), undefined);
+    assert.equal(result.modelDefaultChanged, false);
+  });
+});
+
+test("deletes the thinking default when the effective level is invalid (auto)", async () => {
+  await withSettings(async ({ settings, settingsPath }) => {
+    settings.setDefaultThinkingLevel("high");
+    await settings.flush();
+
+    await persistExplicitStartupPreferences(
+      settings,
+      { thinkingLevel: "auto" },
+      { thinkingLevel: "auto", supportsThinking: true },
+    );
+
+    const saved = JSON.parse(await readFile(settingsPath, "utf8"));
+    assert.equal("defaultThinkingLevel" in saved, false);
+    assert.equal(settings.getDefaultThinkingLevel(), undefined);
+  });
+});
+
+test("does not replace a reasoning default with off for a non-thinking model", async () => {
+  await withSettings(async ({ settings }) => {
+    settings.setDefaultThinkingLevel("high");
+    await settings.flush();
+
+    await persistExplicitStartupPreferences(
+      settings,
+      { thinkingLevel: "off" },
+      { thinkingLevel: "off", supportsThinking: false },
+    );
+
+    assert.equal(settings.getDefaultThinkingLevel(), "high");
+  });
+});

package/lib/startup-preferences.ts

@@ -0,0 +1,65 @@
+import type { ThinkingLevel } from "@earendil-works/pi-agent-core";
+import type { SettingsManager } from "@earendil-works/pi-coding-agent";
+
+/** pi 的合法思考等级；UI 的 "auto" 只是占位，不在此列（写库会被 SDK 兜底成 off）。 */
+const VALID_THINKING_LEVELS = new Set<ThinkingLevel>([
+  "off", "minimal", "low", "medium", "high", "xhigh", "max",
+]);
+
+function isThinkingLevel(value: string): value is ThinkingLevel {
+  return VALID_THINKING_LEVELS.has(value as ThinkingLevel);
+}
+
+export interface ExplicitStartupPreferences {
+  model?: { provider: string; modelId: string };
+  thinkingLevel?: ThinkingLevel;
+}
+
+export interface EffectiveStartupPreferences {
+  model?: { provider: string; modelId: string };
+  thinkingLevel: ThinkingLevel;
+  supportsThinking: boolean;
+}
+
+/**
+ * Persist explicit browser selections without re-running AgentSession setters.
+ *
+ * The session constructor already records the effective model and thinking
+ * level. Calling setModel()/setThinkingLevel() again would append duplicate
+ * session entries and emit duplicate extension events.
+ */
+export async function persistExplicitStartupPreferences(
+  settingsManager: SettingsManager,
+  explicit: ExplicitStartupPreferences,
+  effective: EffectiveStartupPreferences,
+): Promise<{ modelDefaultChanged: boolean }> {
+  if (!explicit.model && !explicit.thinkingLevel) {
+    return { modelDefaultChanged: false };
+  }
+
+  let modelDefaultChanged = false;
+
+  if (
+    explicit.model
+    && effective.model
+    && explicit.model.provider === effective.model.provider
+    && explicit.model.modelId === effective.model.modelId
+  ) {
+    settingsManager.setDefaultModelAndProvider(
+      effective.model.provider,
+      effective.model.modelId,
+    );
+    modelDefaultChanged = true;
+  }
+
+  if (explicit.thinkingLevel && (effective.supportsThinking || effective.thinkingLevel !== "off")) {
+    // auto 是 pi-web 的占位值，pi 不认（SDK 收到会把新会话钳成 off）。
+    // 这里删除字段 = 回到 pi 默认（不写 defaultThinkingLevel），而不是固化 off。
+    // JSON.stringify 会丢弃 undefined 字段值，SDK 落盘时即删除该键。
+    const level = isThinkingLevel(effective.thinkingLevel) ? effective.thinkingLevel : undefined;
+    settingsManager.setDefaultThinkingLevel(level as ThinkingLevel);
+  }
+
+  await settingsManager.flush();
+  return { modelDefaultChanged };
+}

package/lib/streaming-message.test.mjs

@@ -0,0 +1,212 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createJiti } from "jiti";
+
+const jiti = createJiti(import.meta.url);
+const {
+  INITIAL_STREAMING_STATE,
+  streamReducer,
+} = await jiti.import("./streaming-message.ts");
+
+function assistant(content = []) {
+  return {
+    role: "assistant",
+    content,
+    model: "claude-sonnet-4-6",
+    provider: "anthropic",
+    timestamp: 123,
+  };
+}
+
+function snapshot(state, message) {
+  return streamReducer(state, { type: "snapshot", message });
+}
+
+function delta(state, event) {
+  return streamReducer(state, { type: "delta", event });
+}
+
+test("builds thinking and text blocks from official assistant deltas", () => {
+  let state = streamReducer(INITIAL_STREAMING_STATE, { type: "start" });
+  state = snapshot(state, assistant());
+  state = delta(state, { type: "thinking_start", contentIndex: 0 });
+  state = delta(state, { type: "thinking_delta", contentIndex: 0, delta: "Plan" });
+  state = delta(state, { type: "thinking_end", contentIndex: 0, content: "Plan." });
+  state = delta(state, { type: "text_start", contentIndex: 1 });
+  state = delta(state, { type: "text_delta", contentIndex: 1, delta: "Hel" });
+  state = delta(state, { type: "text_delta", contentIndex: 1, delta: "lo" });
+  state = delta(state, { type: "text_end", contentIndex: 1, content: "Hello" });
+
+  assert.equal(state.isStreaming, true);
+  assert.equal(state.streamingMessage.model, "claude-sonnet-4-6");
+  assert.equal(state.streamingMessage.provider, "anthropic");
+  assert.equal(state.streamingMessage.timestamp, 123);
+  assert.deepEqual(state.streamingMessage.content, [
+    { type: "thinking", thinking: "Plan." },
+    { type: "text", text: "Hello" },
+  ]);
+});
+
+test("a reconnect snapshot replaces the old partial before deltas continue", () => {
+  let state = snapshot(INITIAL_STREAMING_STATE, assistant([
+    { type: "text", text: "stale" },
+  ]));
+  state = snapshot(state, assistant([
+    { type: "text", text: "Hello wor" },
+  ]));
+  state = delta(state, { type: "text_delta", contentIndex: 0, delta: "ld" });
+
+  assert.deepEqual(state.streamingMessage.content, [
+    { type: "text", text: "Hello world" },
+  ]);
+});
+
+test("text deltas update immutably so React observes each chunk", () => {
+  const previous = snapshot(INITIAL_STREAMING_STATE, assistant([
+    { type: "text", text: "Hello" },
+  ]));
+  const next = delta(previous, { type: "text_delta", contentIndex: 0, delta: "!" });
+
+  assert.notStrictEqual(next, previous);
+  assert.notStrictEqual(next.streamingMessage, previous.streamingMessage);
+  assert.notStrictEqual(next.streamingMessage.content, previous.streamingMessage.content);
+  assert.equal(previous.streamingMessage.content[0].text, "Hello");
+  assert.equal(next.streamingMessage.content[0].text, "Hello!");
+});
+
+test("shows and streams a tool call after thinking, then accepts the authoritative end", () => {
+  let state = snapshot(INITIAL_STREAMING_STATE, assistant([
+    { type: "thinking", thinking: "I will write the file." },
+  ]));
+
+  state = delta(state, {
+    type: "toolcall_start",
+    contentIndex: 1,
+    id: "call-1",
+    toolName: "write",
+  });
+  assert.deepEqual(state.streamingMessage.content, [
+    { type: "thinking", thinking: "I will write the file." },
+    {
+      type: "toolCall",
+      toolCallId: "call-1",
+      toolName: "write",
+      input: {},
+      rawInput: "",
+    },
+  ]);
+
+  const beforeDelta = state;
+  state = delta(state, {
+    type: "toolcall_delta",
+    contentIndex: 1,
+    delta: '{"path":',
+    id: "call-1",
+    toolName: "write",
+  });
+  state = delta(state, { type: "toolcall_delta", contentIndex: 1, delta: '"/tmp/file"' });
+  assert.notStrictEqual(state, beforeDelta);
+  assert.equal(state.streamingMessage.content[1].rawInput, '{"path":"/tmp/file"');
+
+  state = delta(state, {
+    type: "toolcall_end",
+    contentIndex: 1,
+    toolCall: {
+      type: "toolCall",
+      id: "call-1",
+      name: "write",
+      arguments: { path: "/tmp/file" },
+    },
+  });
+  assert.deepEqual(state.streamingMessage.content, [
+    { type: "thinking", thinking: "I will write the file." },
+    {
+      type: "toolCall",
+      toolCallId: "call-1",
+      toolName: "write",
+      input: { path: "/tmp/file" },
+    },
+  ]);
+  assert.equal(Object.hasOwn(state.streamingMessage.content[1], "rawInput"), false);
+});
+
+test("restores the raw tool input from a reconnect snapshot", () => {
+  const state = snapshot(INITIAL_STREAMING_STATE, assistant([{
+    type: "toolCall",
+    id: "call-2",
+    name: "write",
+    arguments: { path: "/tmp/reconnected" },
+    partialJson: '{"path":"/tmp/reconnected","content":"hel',
+  }]));
+
+  assert.deepEqual(state.streamingMessage.content, [{
+    type: "toolCall",
+    toolCallId: "call-2",
+    toolName: "write",
+    input: { path: "/tmp/reconnected" },
+    rawInput: '{"path":"/tmp/reconnected","content":"hel',
+  }]);
+});
+
+test("ignores deltas without a baseline and unknown future deltas", () => {
+  const started = streamReducer(INITIAL_STREAMING_STATE, { type: "start" });
+  assert.strictEqual(
+    delta(started, { type: "text_delta", contentIndex: 0, delta: "lost" }),
+    started,
+  );
+
+  const withMessage = snapshot(started, assistant());
+  assert.strictEqual(
+    delta(withMessage, { type: "future_delta", contentIndex: 0, delta: "ignored" }),
+    withMessage,
+  );
+});
+
+test("normalizes tool calls in snapshots and clears on end", () => {
+  const state = snapshot(INITIAL_STREAMING_STATE, assistant([{
+    type: "toolCall",
+    id: "call-2",
+    name: "bash",
+    arguments: { command: "pwd" },
+  }]));
+  assert.deepEqual(state.streamingMessage.content, [{
+    type: "toolCall",
+    toolCallId: "call-2",
+    toolName: "bash",
+    input: { command: "pwd" },
+  }]);
+  assert.strictEqual(streamReducer(state, { type: "end" }), INITIAL_STREAMING_STATE);
+});
+
+// Switch-back race: while a session is streaming, the SSE reconnect replays
+// the partial message via `snapshot`. The mount-time state restore runs two
+// fetches AFTER that connection is already open, and its `start` dispatch
+// must NOT wipe the replayed streaming content — otherwise every subsequent
+// text delta is dropped and the typewriter never resumes (the message only
+// pops in whole at message_end).
+test("start preserves an already-replayed streaming message (switch-back race)", () => {
+  let state = snapshot(INITIAL_STREAMING_STATE, assistant([
+    { type: "text", text: "partial reply" },
+  ]));
+  assert.equal(state.isStreaming, true);
+  assert.equal(state.streamingMessage.content[0].text, "partial reply");
+
+  // A late `start` (mount-time state restore completing after the SSE
+  // snapshot replay) must keep the replayed content alive.
+  state = streamReducer(state, { type: "start" });
+  assert.equal(state.isStreaming, true);
+  assert.equal(
+    state.streamingMessage.content[0].text,
+    "partial reply",
+    "start must not wipe replayed streaming content",
+  );
+
+  // Deltas keep appending to the preserved message.
+  state = delta(state, { type: "text_delta", contentIndex: 0, delta: " more" });
+  assert.equal(state.streamingMessage.content[0].text, "partial reply more");
+});
+
+test("start on an empty stream still behaves as before", () => {
+  const state = streamReducer(INITIAL_STREAMING_STATE, { type: "start" });
+  assert.deepEqual(state, { isStreaming: true, streamingMessage: null });
+});