this.tools = tools;

  }

  /**

   * Everything standing that goes to the model: the system message and the tool

   * declarations, rendered from the same values the request carries.

   */

  describeContext(): string {

    const parts = [`System message sent with every turn:\n\n${systemPrompt(this.tools)}`];

    parts.push(

      this.tools.length === 0

        ? "\nNo tools are declared to the model."

        : `\n${String(this.tools.length)} tool${this.tools.length === 1 ? "" : "s"} declared to the model:\n\n${this.tools

            .map(

              (tool) =>

                `- \`${tool.name}\`\n  ${tool.description}\n  parameters: ${JSON.stringify(tool.parameters)}`,

            )

            .join("\n\n")}`,

    );

    return parts.join("\n");

  }

  async *reply(prompt: string, signal: AbortSignal): AsyncIterable<ReplyChunk> {

    // Built on the first turn rather than in the constructor: the tools are

    // declared after construction, and the prompt is derived from them.

   * session then declares no tools rather than declaring tools nothing runs.

   */

  useTools?(tools: ReadonlyArray<CoderTool>): void;

  /**

   * The standing context this source sends with every turn, as text.

   *

   * What `/system` shows. A source reports what it actually sends rather than a

   * description of it, so the two cannot drift: a reader checking why a model

   * behaved a certain way is reading the thing the model read. A source that

   * does not compose its own context leaves this undefined.

   */

  describeContext?(): string;

  /**

   * Yield the reply to `prompt` in chunks. Rendering appends each chunk as it

   * arrives, so a slow source shows partial text rather than nothing.

    // Delegation is not a turn: it does not go to the model, it does not block

    // the next prompt, and it is allowed while a reply is streaming. That is

    // the point of a fleet — the console keeps working while children run.

    // `/system` is not a turn either: it reads what the session already holds,

    // shows it as a notice, and sends nothing. A reader checking what the model

    // was told should not have to change what the model was told to find out.

    if (/^\/system\s*$/.test(prompt.trim())) {

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

      const context = this.source.describeContext?.();

      this.notice(

        context === undefined

          ? "This reply source composes no context of its own, so there is nothing to show."

          : context,

      );

      this.emit();

      return;

    }

    const delegate = parseDelegateCommand(prompt);

    if (delegate !== undefined) {

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

    this.tools = tools;

  }

  /**

   * What this lane sends as standing context.

   *

   * The tool declarations are the client's and are reported in full. The system

   * message is not: the proxy is a completions surface and the server composes

   * what precedes the turn, so this says so rather than printing a prompt this

   * process never saw. A `/system` that guessed would be worse than one that

   * admits the boundary.

   */

  describeContext(): string {

    const declarations =

      this.tools.length === 0

        ? "No tools are declared to the model."

        : `${String(this.tools.length)} tool${this.tools.length === 1 ? "" : "s"} declared to the model:\n\n${this.tools

            .map(

              (tool) =>

                `- \`${tool.name}\`\n  ${tool.description}\n  parameters: ${JSON.stringify(tool.parameters)}`,

            )

            .join("\n\n")}`;

    return [

      "This session runs on a thread. The system message is composed by the server for the",

      "thread's grant and is not sent from this machine, so it cannot be shown here. What follows",

      "is what this process does send with every turn.",

      "",

      declarations,

    ].join("\n");

  }

  /**

   * The grant, for lending to child agents.

   *

    session.notice(

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

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

        "Ctrl+D quits, Esc interrupts a reply. `/system` shows what the model is told.",

    );

    render();

  });

    });

  });

});

describe("the /system command", () => {

  /** A source that records whether the model was reached. */

  const watched = (context?: string): ReplySource & { prompts: string[] } => {

    const prompts: string[] = [];

    return {

      model: "scripted",

      prompts,

      ...(context === undefined ? {} : { describeContext: () => context }),

      // eslint-disable-next-line require-yield -- a turn that must not happen

      async *reply(prompt) {

        prompts.push(prompt);

      },

    };

  };

  it("shows the source's context as a notice and never reaches the model", async () => {

    const reply = watched("System message sent with every turn:\n\nYou are `openagents coder`.");

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

    await session.submit("/system");

    const { entries, turns } = session.snapshot();

    // A notice, so the interface dims it: what the model was told is not

    // something the model said.

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

    expect(entries[1]?.text).toContain("You are `openagents coder`.");

    // Reading what the model was told must not change what the model was told.

    expect(reply.prompts).toEqual([]);

    expect(turns).toBe(0);

  });

  it("says so when the source composes no context of its own", async () => {

    const reply = watched();

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

    await session.submit("/system");

    expect(session.snapshot().entries[1]?.text).toContain("composes no context of its own");

    expect(reply.prompts).toEqual([]);

  });

  it("is the whole line, so a question about the system prompt is still a turn", async () => {

    const reply = watched("context");

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

    await session.submit("what is in your /system prompt");

    expect(reply.prompts).toEqual(["what is in your /system prompt"]);

  });

});