if (event.eventType === "turn.user") {

      entries.push({ role: "you", text: text(payload["text"]), settled: true, at });

    } else if (event.eventType === "turn.reasoning") {

      entries.push({ role: "reasoning", text: text(payload["text"]), settled: true, at });

      const thought = text(payload["text"]);

      // A recorded thought with no text is not a thought. Replaying it as an

      // entry puts a bullet with nothing beside it on the resumed transcript.

      if (thought.length > 0) entries.push({ role: "reasoning", text: thought, settled: true, at });

    } else if (event.eventType === "tool.ran") {

      const name = text(payload["tool"]) || "tool";

      const failure = typeof payload["error"] === "string" ? payload["error"] : undefined;

      const said = text(payload["text"]);

      const interrupted = payload["interrupted"] === true;

      const usage = record(payload["usage"]);

      const metrics =

        Object.keys(usage).length === 0

          ? undefined

          : {

              promptTokens: count(usage["prompt_tokens"]),

              completionTokens: count(usage["completion_tokens"]),

              calls: count(usage["calls"]),

            };

      // A turn that only ran tools is recorded with an empty answer, and an

      // empty answer has nothing to draw: replaying it as an entry is what put

      // a bullet with no text beside it on a resumed transcript. The cost it

      // carried is real, so it lands on the last step the turn actually took.

      if (said.length === 0) {

        const last = entries.at(-1);

        if (metrics !== undefined && last !== undefined && last.metrics === undefined) {

          last.metrics = metrics;

        }

        continue;

      }

      const entry: CoderEntry = {

        role: "assistant",

        text: interrupted && said.length > 0 ? `${said}\n\n[interrupted]` : said,

        text: interrupted ? `${said}\n\n[interrupted]` : said,

        settled: true,

        at,

      };

      if (Object.keys(usage).length > 0) {

        entry.metrics = {

          promptTokens: count(usage["prompt_tokens"]),

          completionTokens: count(usage["completion_tokens"]),

          calls: count(usage["calls"]),

        };

      }

      if (metrics !== undefined) entry.metrics = metrics;

      entries.push(entry);

    }

  }

    let text: CoderEntry | undefined = opening;

    let reasoning: CoderEntry | undefined;

    /**

     * Every prose entry this turn opened, filled or not.

     *

     * Held so the turn can withdraw the ones nothing ever arrived for. Tool

     * entries are not in it: a call with no output is still a call that ran.

     */

    const opened = new Set<CoderEntry>([opening]);

    const settle = (entry: CoderEntry | undefined) => {

      if (entry !== undefined) entry.settled = true;

    };

      const at = this.entries.indexOf(opening);

      if (at >= 0 && opening.text.length === 0) this.entries.splice(at, 1);

    };

    /**

     * Withdraw what the turn opened and no chunk ever filled.

     *

     * The opening entry is a caret, not a turn: it is there so the interface

     * shows something while the first chunk is in flight. Until now it was

     * withdrawn only when the turn went on to reason or call a tool, so a turn

     * that produced nothing at all — a source that yielded no chunks, an

     * escape pressed before the first one — settled it empty and left a bullet

     * with nothing beside it on the transcript for the rest of the session.

     * `/export` has always skipped these; the interface now does too.

     */

    const withdrawEmpty = () => {

      for (const entry of opened) {

        if (entry.text.length > 0) continue;

        const at = this.entries.indexOf(entry);

        if (at === -1) continue;

        this.entries.splice(at, 1);

        // The turn's cost was reported onto whatever entry it ended on. If

        // that was this placeholder, it moves to the entry that is really

        // last, so withdrawing a caret does not take the figures with it.

        if (entry.metrics === undefined) continue;

        const last = this.entries.at(-1);

        if (last !== undefined && last.metrics === undefined) last.metrics = entry.metrics;

      }

    };

    const controller = new AbortController();

    this.controller = controller;

            reasoning = undefined;

            text = { role: "assistant", text: "", settled: false, at: Date.now() };

            this.entries.push(text);

            opened.add(text);

          }

          text.text += chunk.value;

        } else if (chunk.type === "reasoning") {

            text = undefined;

            reasoning = { role: "reasoning", text: "", settled: false, at: Date.now() };

            this.entries.push(reasoning);

            opened.add(reasoning);

          }

          reasoning.text += chunk.value;

        } else if (chunk.type === "tool_call") {

      }

      this.entries.push({ role: "notice", text: message, settled: true, at: Date.now() });

    } finally {

      withdrawEmpty();

      for (const entry of this.entries) {

        if (entry.settled) continue;

        entry.settled = true;

      // One blank row between entries. It is what keeps a tool call from

      // reading as part of the sentence before it.

      for (const entry of snapshot.entries) {

        // An entry that settled with nothing in it draws nothing. The dot is

        // the interface saying somebody spoke, and a dot beside an empty line

        // says it about a turn that never happened. A turn still streaming is

        // a different case: it has nothing yet and shows a caret.

        if (drawsNothing(entry)) continue;

        if (out.length > 0) out.push("");

        out.push(...renderEntry(entry, body, sidebar ? [] : snapshot.tasks));

      }

      return out;

    };

    /** Whether an entry would render as a bullet and a blank line. */

    const drawsNothing = (entry: CoderEntry): boolean =>

      entry.role !== "tool" && entry.settled && entry.text.length === 0;

    const renderEntry = (

      entry: CoderEntry,

      width: number,

    expect(interrupted?.text).toBe("There is no VERSION file;\n\n[interrupted]");

  });

  it("does not replay a turn that said nothing as an entry", () => {

    // A turn that only ran tools is recorded with an empty answer. Replaying

    // it put a bullet with nothing beside it on the resumed transcript, and

    // the cost it carried belongs on the last step the turn actually took.

    const entries = replayEntries([

      ...FIXTURE,

      {

        id: 8,

        eventType: "tool.ran",

        payload: {

          call_id: "call-3",

          tool: "shell",

          arguments: `{"command":"ls"}`,

          status: "succeeded",

          output: "mix.exs",

        },

        emittedAt: "2026-08-24T12:00:08Z",

      },

      {

        id: 9,

        eventType: "turn.assistant",

        payload: {

          text: "",

          usage: { prompt_tokens: 40, completion_tokens: 0, total_tokens: 40, calls: 1 },

          tool_calls: 1,

        },

        emittedAt: "2026-08-24T12:00:09Z",

      },

    ]);

    expect(entries).toHaveLength(8);

    expect(entries.at(-1)?.role).toBe("tool");

    expect(entries.at(-1)?.metrics).toEqual({

      promptTokens: 40,

      completionTokens: 0,

      calls: 1,

    });

  });

  it("does not replay a recorded thought that has no text", () => {

    const entries = replayEntries([

      { id: 1, eventType: "turn.user", payload: { text: "go" }, emittedAt: undefined },

      { id: 2, eventType: "turn.reasoning", payload: { text: "" }, emittedAt: undefined },

      { id: 3, eventType: "turn.assistant", payload: { text: "done" }, emittedAt: undefined },

    ]);

    expect(entries.map((entry) => entry.role)).toEqual(["you", "assistant"]);

  });

  it("skips event types outside the vocabulary rather than refusing the replay", () => {

    const entries = replayEntries([

      { id: 1, eventType: "thread.noted", payload: { note: "?" }, emittedAt: undefined },

    expect(session.snapshot().running).toBe(false);

  });

  it("withdraws the opening entry when the turn produces nothing", async () => {

    const session = new CoderSession(source([]), "repo", "main");

    await session.submit("go");

    // The empty assistant entry is the caret shown while the first chunk is in

    // flight. A turn that never produced one used to settle it empty, and the

    // interface drew a dot with nothing beside it.

    expect(session.snapshot().entries.map((entry) => entry.role)).toEqual(["you"]);

  });

  it("withdraws the opening entry when the turn is interrupted before its first chunk", async () => {

    const session = new CoderSession(scripted(["a"], 40), "repo", "main");

    const pending = session.submit("go");

    await new Promise((resolve) => setTimeout(resolve, 5));

    expect(session.interrupt()).toBe(true);

    await pending;

    expect(session.snapshot().entries.map((entry) => entry.role)).toEqual(["you"]);

  });

  it("keeps a withdrawn placeholder's cost on the entry that is left", async () => {

    const session = new CoderSession(

      source([

        { type: "usage", promptTokens: 12, completionTokens: 0, calls: 1 },

      ] as ReadonlyArray<ReplyChunk>),

      "repo",

      "main",

    );

    await session.submit("go");

    const entries = session.snapshot().entries;

    expect(entries.map((entry) => entry.role)).toEqual(["you"]);

    // Withdrawing the caret must not withdraw what the turn cost with it.

    expect(entries[0]?.metrics?.promptTokens).toBe(12);

  });

  it("queues a prompt typed during a turn, and sends it when the turn ends", async () => {

    const sent: string[] = [];

    const recording: ReplySource = {

    expect(rows.join("\n")).not.toContain("connected:Here");

  });

  it("draws no bullet for an entry that settled with nothing in it", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    const session = new CoderSession(source([{ type: "text", value: "hello" }]), "repo", "main");

    // A blank entry the interface is handed anyway: a record replayed from a

    // turn that only ran tools used to restore as one. The dot says somebody

    // spoke, and beside an empty line it says it about a turn that never

    // happened.

    session.restore([

      { role: "you", text: "earlier", settled: true, at: Date.now() },

      { role: "assistant", text: "", settled: true, at: Date.now() },

    ]);

    const running = runCoderUi(session, {

      stdin: stdin as unknown as NodeJS.ReadStream,

      stdout: stdout as unknown as NodeJS.WriteStream,

    });

    await session.submit("go");

    const rows = screen(stdout.written);

    stdin.emit("data", "\x04");

    await running;

    const bullets = rows.filter((row) => row.trimStart().startsWith("\u25cf"));

    expect(bullets.length).toBeGreaterThan(0);

    expect(bullets.every((row) => row.replace("\u25cf", "").trim().length > 0)).toBe(true);

  });

  it("shows the tool, its call, and its outcome, on two rows", async () => {

    const { rows } = await drive([

      { type: "tool_call", callId: "c1", name: "repo_grep", arguments: '{"pattern":"x"}' },