export class ChatApiReplySource {

  private backend: CoderBackend;

  /**

   * The server records one conversation per account, so a turn submitted here

   * lands in the same conversation `/chat` writes to and every earlier

   * `openagents coder` run wrote to. That is why the model remembers a

   * question this terminal never asked, and there is nothing else on screen

   * that would tell a reader so. The Thread work replaces this; until a thread

   * exists the interface must not imply the session is private to this

   * terminal.

   */

  readonly scopeNotice =

    "This conversation is the account's one conversation, shared with /chat " +

    "and with earlier coder runs, so the model remembers turns from all of them.";

  constructor(private readonly options: ChatApiOptions) {

    this.backend = options.backend ?? defaultBackend();

  }

    }

  };

  // Where the turns are recorded is a property of the session, not of the

  // interface, so the piped path says it too rather than leaving it to the

  // one reader who happens to be on a TTY.

  const scope = session.snapshot().scope;

  if (scope !== undefined) stdout.write(`${scope}\n`);

  const unsubscribe = session.onChange(flush);

  flush();

   * this process never saw.

   */

  readonly turns: number;

  /**

   * What a reader needs to know about where this source records its turns, or

   * undefined when there is nothing to say. Shown once, at the start.

   */

  readonly scope: string | undefined;

}

/** Where reply chunks come from. One implementation today; ACP is the next. */

   * leaves it unset; a source that writes into a conversation shared with

   * another surface has to say so, because nothing else on screen would.

   */

  readonly scopeNotice?: string;

  /**

   * Move to the next backend and return its new label.

   *

      branch: this.branch,

      model: this.source.model,

      turns: this.turnCount,

      scope: this.source.scopeNotice,

    };

  }

      "openagents coder — development build. Type a message and press enter. " +

        "Ctrl+D quits, Esc interrupts a reply.",

    );

    const scope = session.snapshot().scope;

    if (scope !== undefined) session.notice(scope);

    render();

  });

}

    expect(new Set(labels).size).toBe(CODER_BACKENDS.length);

    expect(cycling.model).toBe(defaultBackend().label);

  });

  it("says that its turns land in the account's one shared conversation", () => {

    // The server records one conversation per account, so this source cannot

    // let the interface imply the session is private to one terminal.

    expect(source().scopeNotice).toContain("/chat");

    expect(source().scopeNotice).toContain("remembers");

  });

});

    expect(session.snapshot().turns).toBe(1);

  });

  it("carries the source's scope notice, and nothing when the source has none", () => {

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

    expect(local.snapshot().scope).toBeUndefined();

    const shared = new CoderSession(

      { ...scripted([]), scopeNotice: "shared with /chat" },

      "repo",

      "main",

    );

    expect(shared.snapshot().scope).toBe("shared with /chat");

  });

  it("carries workspace and model into the snapshot for the status line", () => {

    const session = new CoderSession(new DummyReplySource(), "openagents", "main");

    const snapshot = session.snapshot();

    expect(rows.at(-1)).toContain("1 reply this run");

  });

  it("says once where the turns are recorded when the source is not private", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    const session = new CoderSession(

      { ...source([{ type: "text", value: "hi" }]), scopeNotice: "shared with /chat" },

      "repo",

      "main",

    );

    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 notes = rows.filter((row) => row.includes("shared with /chat"));

    expect(notes).toHaveLength(1);

    expect(notes[0]).toContain("note");

  });

  it("says nothing about scope when the source keeps its turns to itself", async () => {

    const { rows } = await drive([{ type: "text", value: "hello" }]);

    expect(rows.join("\n")).not.toContain("shared with");