readonly tool?: CoderToolCall;

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

  metrics?: CoderMetrics;

  /**

   * What this notice replaces, when it replaces one.

   *

   * Two notices about the same setting are one notice: the second is what is

   * true and the first is what used to be.

   */

  readonly supersedes?: string;

}

/** Everything a renderer needs. No renderer reads anything else. */

      return { changed: false, level: this.source.reasoning?.level };

    }

    const level = this.source.cycleReasoning();

    this.notice(`Reasoning set to ${level}.`);

    this.notice(`Reasoning set to ${level}.`, "reasoning");

    return { changed: true, level };

  }

    }

    const label = this.source.cycleBackend();

    this.notice(`Model switched to ${label}.`);

    this.notice(`Model switched to ${label}.`, "model");

    return { switched: true, label };

  }

    return () => this.listeners.delete(listener);

  }

  notice(text: string): void {

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

  notice(text: string, supersedes?: string): void {

    // A notice that supersedes another replaces it rather than stacking under

    // it. Cycling the reasoning level four times left four notes saying what it

    // had been set to, three of which were no longer true, and the reader had

    // to read to the bottom to find the one that was.

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

    if (

      supersedes !== undefined &&

      last !== undefined &&

      last.role === "notice" &&

      last.supersedes === supersedes

    ) {

      last.text = text;

      this.emit();

      return;

    }

    this.entries.push({

      role: "notice",

      text,

      settled: true,

      at: Date.now(),

      ...(supersedes === undefined ? {} : { supersedes }),

    });

    this.emit();

  }

    expect(assistant?.metrics).toEqual({ promptTokens: 12, completionTokens: 34, calls: 2 });

  });

});

describe("notices that replace one another", () => {

  it("keeps the last of a run about the same setting, and only the last", async () => {

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

    session.notice("Reasoning set to low.", "reasoning");

    session.notice("Reasoning set to high.", "reasoning");

    session.notice("Reasoning set to off.", "reasoning");

    expect(session.snapshot().entries.map((entry) => entry.text)).toEqual([

      "Reasoning set to off.",

    ]);

  });

  it("does not fold two notices that are about different things", async () => {

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

    session.notice("Reasoning set to low.", "reasoning");

    session.notice("Model switched to Ox Alpha.", "model");

    session.notice("Reasoning set to high.", "reasoning");

    // The model notice separates them, so the second reasoning notice is a new

    // one rather than a replacement: what it replaced is no longer the last

    // thing said.

    expect(session.snapshot().entries).toHaveLength(3);

  });

  it("leaves an ordinary notice alone", async () => {

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

    session.notice("Interrupted.");

    session.notice("Interrupted.");

    // Two interruptions are two events, not one restated.

    expect(session.snapshot().entries).toHaveLength(2);

  });

});

    stdin.emit("data", "\x1b[9;2u");

    expect(session.snapshot().reasoning).toBe("medium");

    // Four presses left four notes, three of which were no longer true.

    stdin.emit("data", "\x1b[Z");

    stdin.emit("data", "\x1b[Z");

    const notes = session

      .snapshot()

      .entries.filter((entry) => entry.text.startsWith("Reasoning set to"))

      .map((entry) => entry.text);

    expect(notes).toEqual(["Reasoning set to off."]);

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

    await running;

  });