// Anything the reader said since the last step joins here, before the

      // model is asked again. It reads as an ordinary turn in the conversation,

      // because that is what it is.

      for (const said of this.steered.splice(0)) {

      const steered = this.steered.splice(0);

      for (const said of steered) {

        this.transcript.push({ role: "user", content: said });

      }

      // The interface dims a steered message until this says it was read.

      if (steered.length > 0) yield { type: "steered", texts: steered };

      const calls: OllamaToolCall[] = [];

      let assistant = "";

      readonly callId: string;

      readonly output: string | undefined;

      readonly error: string | undefined;

    }

  | {

      /**

       * What the reader steered, at the moment the model was given it.

       *

       * A steered message is typed while the model is working and read at its

       * next step, which can be seconds later and several tool calls down. The

       * transcript showed it where it was typed, settled, indistinguishable

       * from a message that had been answered — so a reader could not tell

       * what the model had actually seen. The source says when it hands one

       * over, and the entry moves to that point and stops looking pending.

       */

      readonly type: "steered";

      readonly texts: ReadonlyArray<string>;

    };

/** The tool half of a `tool` entry. Grows when the outcome arrives. */

  settled: boolean;

  /** Present on a `tool` entry only. */

  readonly tool?: CoderToolCall;

  /**

   * Set on a steered `you` entry the model has not been given yet.

   *

   * The interface dims it. It is the difference between "you said this" and

   * "you said this and it was heard", and a turn is long enough that the two

   * are not the same fact.

   */

  pending?: boolean;

  /** Set on the entry a turn ended on, when the source reported the cost. */

  metrics?: CoderMetrics;

  /**

    // Typing while the model works is how a reader steers, and an interface

    // that silently ignores the key is one that cannot be steered at all.

    if (this.controller !== undefined) {

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

      // Steering by default: a source that runs a loop of model calls reads

      // this at its next step, so the model sees it while it is still working.

      // A reader who wants the turn finished first asks for `queue`, and a

      // source that cannot steer holds it to the end either way.

      if (mode === "steer" && this.source.steer?.(prompt) === true) {

        this.notice("Steering: the model reads this at its next step.");

        // Pending until the source says it handed it over. It used to land

        // here settled, with a notice under it saying the model would read it

        // later — which is a sentence describing what the entry itself should

        // have been showing.

        this.entries.push({

          role: "you",

          text: prompt,

          settled: true,

          at: Date.now(),

          pending: true,

        });

        this.emit();

        return;

      }

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

      this.pending.push(prompt);

      this.notice(

        this.pending.length === 1

              ...(provenance === undefined ? {} : { plugin: provenance }),

            },

          });

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

          // Moved to where the model was actually given it, which is here: the

          // source yields this as it splices the message into the transcript,

          // so the current end of the entries is that point in the chain.

          for (const said of chunk.texts) {

            const at = this.entries.findIndex(

              (entry) => entry.role === "you" && entry.pending === true && entry.text === said,

            );

            if (at === -1) continue;

            const [entry] = this.entries.splice(at, 1);

            if (entry === undefined) continue;

            entry.pending = false;

            this.entries.push(entry);

          }

          // The streaming entries are the ones being appended to, and the

          // splice moved the transcript out from under them. Reopening keeps

          // the next chunk from growing an entry that is no longer last.

          text = undefined;

          reasoning = undefined;

          this.emit();

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

          // Onto the entry the turn ended on, which is the step a reader of the

          // trajectory would attribute the cost to. `calls` says how many LLM

      for (let step = 0; ; step += 1) {

        // Anything the reader said since the last step joins here, before the

        // model is asked again.

        for (const said of this.steered.splice(0)) {

        const steered = this.steered.splice(0);

        for (const said of steered) {

          this.transcript.push({ role: "user", content: said });

          // Steered mid-turn rather than asked between turns, and the record

          // says so, or a replay would show a question the answer ignores.

          this.sink?.record("turn.user", { text: said, steered: true });

        }

        // The interface dims a steered message until this says it was read.

        if (steered.length > 0) yield { type: "steered", texts: steered };

        const calls: WireCall[] = [];

        let assistant = "";

        return renderMarkdown(entry.text, width, `${DIM}${ITALIC}`);

      }

      if (entry.role === "assistant") return renderMarkdown(entry.text, width);

      // A steered message the model has not been given yet, dim and italic:

      // the same styling reasoning gets, for the same reason — it is on screen

      // but it is not part of the conversation yet.

      if (entry.role === "you" && entry.pending === true) {

        return wrapStyled(entry.text, width, `${DIM}${ITALIC}`);

      }

      return wrapStyled(entry.text, width, entry.role === "notice" ? DIM : "");

    };

      // Read between two model calls rather than at the end of the turn, which

      // is the difference between steering a model and waiting one out.

      for (const said of this.steered.splice(0)) {

      const steered = this.steered.splice(0);

      for (const said of steered) {

        this.transcript.push({ role: "user", content: said });

      }

      // The interface dims a steered message until this says it was read.

      if (steered.length > 0) yield { type: "steered", texts: steered };

      const calls: Map<number, { id: string; name: string; args: string }> = new Map();

      let assistant = "";

    // It arrived at a later step, not at the start.

    const first = requests[0]?.["messages"] as ReadonlyArray<Record<string, unknown>>;

    expect(first.map((m) => m["content"])).not.toContain("actually, do it the other way");

    expect(session.snapshot().entries.filter((e) => e.role === "notice").map((e) => e.text))

      .toContainEqual(expect.stringContaining("Steering"));

    // The message itself says it was steered, rather than a notice under it

    // saying the model will read it later.

    const entries = session.snapshot().entries;

    const steered = entries.filter((e) => e.role === "you" && e.text.startsWith("actually,"));

    expect(steered).toHaveLength(1);

    expect(steered[0]?.pending).toBe(false);

    // And it sits where the model was given it, not where it was typed: after

    // the tool call it arrived during.

    const at = entries.findIndex((e) => e.text.startsWith("actually,"));

    const tool = entries.findIndex((e) => e.role === "tool");

    expect(tool).toBeGreaterThanOrEqual(0);

    expect(at).toBeGreaterThan(tool);

    // No notice at all: the entry carries the fact now.

    expect(entries.filter((e) => e.role === "notice").map((e) => e.text)).not.toContainEqual(

      expect.stringContaining("Steering"),

    );

  });

  it("shows a steered message as pending until the model is given it", async () => {

    const gate: Array<() => void> = [];

    let round = 0;

    const source = new OllamaReplySource({ model: "m" });

    (source as unknown as { client: unknown }).client = {

      chat: async () => {

        const mine = round++;

        const pieces =

          mine === 0

            ? [

                chunk({ content: "", tool_calls: [{ function: { name: "t", arguments: {} } }] }),

                chunk({}, true),

              ]

            : [chunk({ content: "done" }, true)];

        return Object.assign(

          (async function* () {

            if (mine === 0) await new Promise<void>((r) => gate.push(r));

            for (const p of pieces) yield p;

          })(),

          { abort: () => {} },

        );

      },

    };

    source.useTools([

      { name: "t", description: "d", parameters: {}, run: () => Promise.resolve("ok") },

    ]);

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

    const turn = session.submit("original question");

    await new Promise((r) => setTimeout(r, 10));

    await session.submit("steer me");

    // Typed, on screen, and not yet part of the conversation. This is the gap

    // the dimming exists for: the model has not seen it, and a settled entry

    // said it had.

    const waiting = session

      .snapshot()

      .entries.find((e) => e.role === "you" && e.text === "steer me");

    expect(waiting?.pending).toBe(true);

    gate.shift()?.();

    await turn;

    await new Promise((r) => setTimeout(r, 20));

    const read = session.snapshot().entries.find((e) => e.text === "steer me");

    expect(read?.pending).toBe(false);

  });

});