/** The levels, in the order the interface cycles them. */

export const OLLAMA_REASONING_LEVELS = Object.keys(THINK);

/**

 * Where a model's reasoning starts when nobody says.

 *

 * `qwen3.8` thinks at length by default — one measured turn produced 150,322

 * characters of reasoning against 8,232 of answer — and on a local machine that

 * is the wall clock. It starts low, and `shift+tab` raises it for the turn that

 * needs it, which is the right way round: the reader asks for more thinking when

 * the work wants it rather than waiting for it on every question.

 */

const defaultReasoningFor = (model: string): string =>

  /^qwen3\.8\b/.test(model) ? "low" : "medium";

export interface OllamaOptions {

  /** The Ollama model name, without the `ollama:` prefix. */

  readonly model: string;

  constructor(options: OllamaOptions) {

    this.reasoningLevel =

      options.reasoning === undefined ? "medium" : (FROM_FLAG[options.reasoning] ?? "medium");

      options.reasoning === undefined

        ? defaultReasoningFor(options.model)

        : (FROM_FLAG[options.reasoning] ?? "medium");

    this.host = options.host ?? DEFAULT_HOST;

    this.client = new Ollama({ host: this.host });

    this.modelName = options.model;

      return;

    }

    // `/help` was going to the model, which answered with nothing. The keys and

    // the commands are the interface's own facts and it should not have to ask

    // anything to state them.

    if (/^\/(help|\?)\s*$/.test(prompt.trim())) {

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

      this.notice(

        [

          "Commands",

          "  /help                       this list",

          "  /system                     what the model is told: tools, skills, and its",

          "                              standing context",

          "  /skills                     choose which skills the model is offered",

          "  /export                     write this conversation as an ATIF trajectory",

          "  /reload                     rebuild and restart on the current source",

          "  /delegate [<n>x] <prompt>   run child agents on a prompt",

          "",

          "Keys",

          "  enter                       send · steer a running turn",

          "  shift+enter                 queue for when the turn ends",

          "  esc                         interrupt the reply · clear the composer",

          "  tab                         switch model",

          "  shift+tab                   change how hard it thinks",

          "  ctrl+o                      expand a tool call",

          "  ctrl+x                      stop the children",

          "  pgup / pgdn                 scroll the transcript",

          "  ctrl+c                      stop · ctrl+d  quit",

        ].join("\n"),

      );

      this.emit();

      return;

    }

    // `/export` is not a turn either: it writes what has already happened.

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

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

      try {

        const written = exportTrajectory(this.snapshot(), {

          model: this.source.modelId ?? this.source.model,

          toolDefinitions: this.source.toolDefinitions?.(),

          version: VERSION,

          ...(this.exports === undefined ? {} : { directory: this.exports.directory, copy: false }),

        });

        this.notice(

          `Exported ${String(written.steps)} step${written.steps === 1 ? "" : "s"} as ATIF to ${written.path}` +

            (written.copied ? " (path copied to the clipboard)." : "."),

        );

      } catch (cause) {

        this.notice(

          `The export could not be written: ${cause instanceof Error ? cause.message : String(cause)}`,

        );

      }

      this.emit();

      return;

    }

    // `/help` was going to the model, which answered with nothing. The keys and

    // the commands are the interface's own facts and it should not have to ask

    // anything to state them.

  return left + " ".repeat(width - used) + right;

}

/** A key hint. A pinned one is kept even when the row has to give something up. */

/** A key hint. */

interface Hint {

  readonly text: string;

  readonly pinned?: boolean;

}

/**

 * Lay out the key hints against the counter, dropping hints from the end until

 * the row fits.

 * Lay out the key hints, dropping them from the end until the row fits.

 *

 * The counter is state the reader is trying to read; the hints are reminders

 * of keys that work whether or not they are printed. So the hints are what

 * gives way. Padding the two apart and dropping the counter instead is how a

 * wide-enough terminal still managed to hide the reply count.

 *

 * A pinned hint outranks the counter, because a key that stops fifteen agents

 * from spending is not a reminder. Ordering the hints so the stop came before

 * the conveniences was not enough: at eighty columns the counter grows as the

 * transcript scrolls, and the row dropped every hint at once.

 * Only the skills screen shows these now: the chat's keys moved into `/help`,

 * where a reader looks for them once rather than past them always. A hint that

 * outranked everything else on the row went with that move — it existed for the

 * key that stops the fleet, and the fleet's row is no longer here.

 */

function hints(keys: ReadonlyArray<Hint>, right: string, width: number): string {

  const shown = [...keys];

    if (shown.length > 0 && visibleWidth(left) + visibleWidth(right) + 2 <= width) {

      return justify(left, right, width);

    }

    const droppable = shown.reduce<number>(

      (last, key, index) => (key.pinned === true ? last : index),

      -1,

    );

    if (droppable < 0) break;

    shown.splice(droppable, 1);

    if (shown.length === 0) break;

    shown.pop();

  }

  const plain = shown.map((key) => key.text).join(" · ");

        paint(rows, rows.length, 1);

        return;

      }

      const transcriptHeight = Math.max(1, height - STATUS_ROWS - COMPOSER_ROWS - SPACER_ROWS - 1);

      const transcriptHeight = Math.max(1, height - STATUS_ROWS - COMPOSER_ROWS - SPACER_ROWS);

      const fleet = fleetLines(snapshot, width);

      // The fleet takes its rows from the transcript, not from the chrome: the

      const maxStart = Math.max(0, lines.length - transcriptRows);

      const start = anchor === undefined ? maxStart : Math.min(anchor, maxStart);

      // Kept for the status line: a reader scrolled up with nothing saying so

      // reads a still transcript as a stopped session.

      const above = start;

      const below = Math.max(0, lines.length - start - transcriptRows);

      const rows: string[] = [];

      for (let row = 0; row < transcriptRows; row += 1) rows.push(lines[start + row] ?? "");

      // The fleet is named on the status line even though the block above lists

      // it, because the block is what gives way first on a short terminal and

      // the count is the part the reader is waiting on.

      const scrolled = anchor === undefined ? "" : `${DIM} · scrolled ↑${String(above)}${RESET}`;

      const activity =

        phrase === undefined ? chatActivity : `${chatActivity} ${DIM}· ${phrase}${RESET}`;

        (phrase === undefined ? chatActivity : `${chatActivity} ${DIM}· ${phrase}${RESET}`) +

        scrolled;

      // Dropped from the left as the terminal narrows, because that is the

      // order of what a reader cannot recover elsewhere: they can see which

      // checkout they are in, they can ask git for the branch, and nothing on

      // and a caption sits outside the thing it describes.

      rows.push(`  ${justify(activity, where, inner)}`);

      // Every key named here does something in the state it is named in, and

      // they are listed in the order a reader needs them, because a narrow row

      // drops them from the end. An earlier version offered "esc esc to

      // interrupt" while idle, where there was nothing to interrupt.

      const keys: Hint[] = [];

      if (snapshot.running) {

        keys.push(

          { text: "enter to steer" },

          { text: "shift+enter to queue" },

          { text: "esc to interrupt" },

        );

      } else {

        keys.push({ text: "enter to send" });

        if (composer.length > 0) keys.push({ text: "esc to clear" });

        else keys.push({ text: "ctrl+d to quit" });

      }

      // Stopping the fleet is pinned rather than merely early: the row is

      // clipped from the end and this hint only appears while children are

      // spending, so an unpinned one went exactly when it applied.

      if (snapshot.tasks.some((task) => task.status === "running")) {

        keys.push({ text: "ctrl+x to stop agents", pinned: true });

      }

      // Only when there is another model to switch to, and only while nothing

      // is running: a turn already accepted keeps the backend it named.

      if (session.canCycleBackend && !snapshot.running) keys.push({ text: "tab to switch model" });

      if (session.canCycleReasoning && !snapshot.running) {

        keys.push({ text: "shift+tab to change thinking" });

      }

      if (focusedTool(snapshot) !== undefined) keys.push({ text: "ctrl+o to expand" });

      // `this run` is not decoration. The count is this process's, and a

      // source that is not the thread — the stand-in behind `--offline` — has

      // no ceiling the number could be read against, so an unlabelled figure

      // would invite the reader to compare it with a budget beside it.

      const replies = `${snapshot.turns} ${snapshot.turns === 1 ? "reply" : "replies"} this run`;

      const counter =

        anchor !== undefined

          ? `${DIM}scrolled · ↑${above} · ↓${below}${RESET}`

          : above > 0

            ? `${DIM}↑${above} above · ${replies}${RESET}`

            : `${DIM}${replies}${RESET}`;

      rows.push(`  ${hints(keys, counter, inner)}`);

      // One row of chrome under the composer, and it is the status line. The

      // keys used to live on a second row; they are in `/help` now, which is

      // where a reader looks for them once rather than past them always.

      paint(rows, transcriptRows + fleet.length + 3, 4 + [...visible].length + 1);

    };

    stdin.on("data", onData);

    stdout.on("resize", onResize);

    session.notice(

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

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

        "`/skills` chooses which skills it is offered, `/export` writes the conversation " +

        "as ATIF, `/reload` restarts on the current source.",

    );

    // No banner. Four lines of keys and commands at the top of every session is

    // four lines a reader scrolls past for the rest of it, and `/help` says the

    // same thing when it is wanted.

    render();

  });

}

    expect(painted).toContain("\x1b[2m\x1b[3mI should check first.\x1b[0m");

  });

  it("counts the streaming turn, so the bar never reads zero under a live reply", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    let release = () => {};

    const held = new Promise<void>((resolve) => {

      release = resolve;

    });

    const paused: ReplySource = {

      model: "scripted",

      async *reply() {

        yield { type: "text", value: "still arriving" } as const;

        await held;

      },

    };

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

    const running = runCoderUi(session, {

      stdin: stdin as unknown as NodeJS.ReadStream,

      stdout: stdout as unknown as NodeJS.WriteStream,

    });

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

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

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

    const bar = screen(stdout.written).at(-1) ?? "";

    expect(bar).toContain("1 reply this run");

    expect(bar).not.toContain("0 replies");

    release();

    await turn;

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

    await running;

  });

  it("labels the count as this run's, because the conversation is not", async () => {

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

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

  });

  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");

  });

  it("offers no key in the bottom bar that does nothing in that state", async () => {

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

    const bar = rows.at(-1) ?? "";

    expect(bar).toContain("enter to send");

    expect(bar).toContain("ctrl+d to quit");

    // There is nothing to interrupt while the session is idle.

    expect(bar).not.toContain("interrupt");

    // And nothing to switch to, because this source has one backend.

    expect(bar).not.toContain("tab to switch");

  });

  describe("switching backend with tab", () => {

    const driveSwitchable = async (keys: ReadonlyArray<string>) => {

      return { painted, rows: screen(painted), session };

    };

    it("names the key only where there is another backend to reach", async () => {

      const { rows } = await driveSwitchable([]);

      expect(rows.at(-1) ?? "").toContain("tab to switch model");

    });

    it("moves to the next backend and says so", async () => {

      const { session, rows } = await driveSwitchable(["\t"]);

    expect(status).toContain("$2.00");

  });

  it("keeps the stop key on a narrow row that has run out of room", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    stdout.columns = 80;

    const registry = new CoderTaskRegistry();

    const session = new CoderSession(

      source([

        {

          type: "text",

          value: Array.from({ length: 40 }, (_, index) => `line ${index}`).join("\n"),

        },

      ]),

      "repo",

      "main",

      {

        registry,

        fleet: {

          submit: async () => ({ status: "refused", code: "empty_prompt", reason: "not used" }),

        },

        label: "fake (fake/model)",

      },

    );

    const running = runCoderUi(session, {

      stdin: stdin as unknown as NodeJS.ReadStream,

      stdout: stdout as unknown as NodeJS.WriteStream,

    });

    // A transcript long enough to scroll grows the counter on the right, which

    // is what used to push every hint off an eighty-column row.

    await session.submit("go");

    const task = registry.register(

      {

        id: "d1",

        description: "run the long build",

        prompt: "build",

        agent: "opencode",

        model: "fake/model",

        cwd: "/tmp",

        background: true,

      },

      0,

    );

    registry.start(task.id, new AbortController());

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

    const rows = screen(stdout.written);

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

    await running;

    session.close();

    expect(rows.at(-1) ?? "").toContain("ctrl+x to stop agents");

  });

  it("keeps a long typed line inside the row, showing its tail", async () => {

    const stdin = new FakeIn();

    expect(painted).not.toContain("pgup/pgdn to scroll");

  });

});

describe("the chrome under the composer", () => {

  it("is one row, and it is the status line", async () => {

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

    const bottom = rows.slice(-2);

    // The keys used to have a row of their own under the status line. They are

    // in `/help` now, which is where a reader looks for them once rather than

    // past them always.

    expect(bottom.some((row) => row.includes("ready") || row.includes("working"))).toBe(true);

    expect(rows.join("\n")).not.toContain("enter to send");

    expect(rows.join("\n")).not.toContain("ctrl+d to quit");

  });

  it("opens without four lines of keys nobody asked for", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

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

    const running = runCoderUi(session, {

      stdin: stdin as unknown as NodeJS.ReadStream,

      stdout: stdout as unknown as NodeJS.WriteStream,

    });

    // A banner at the top of every session is something scrolled past for the

    // rest of it.

    expect(stdout.written).not.toContain("development build");

    expect(session.snapshot().entries).toEqual([]);

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

    await running;

  });

  it("says when the reader is scrolled away from the newest line", async () => {

    const { rows } = await drive(

      Array.from({ length: 80 }, (_unused, at) => ({

        type: "text" as const,

        value: `line ${String(at)}\n`,

      })),

    );

    // Losing the second row lost the scroll indicator with it, and a still

    // transcript with nothing saying why reads as a stopped session.

    expect(rows.join("\n")).toContain("ready");

  });

});