"note": "Heuristic false-green LEADS, not findings. A finding requires a demonstrated reproduction (surviving mutation via mutation-runner). Do not treat a candidate as a confirmed false green. Coverage-theater leads may include tests that delegate their assertion to a custom helper the classifier does not recognise; verify before acting.",

  "sourceDigest": "sha256:dd810dd48c5bdbc9becd7fcc01dd41a4ca2abf0b2d6f6a545907247f6e3e8361",

  "summary": {

    "filesScanned": 2444,

    "filesScanned": 2445,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:a813bcd9bb356638c4366fc0cf61cd2444992879b1371490642b0b562ef1bb01",

  "sourceDigest": "sha256:093efa8ee710da1f837de6a42b2dbe0b02438975c432ec7df9f71da5ba6c4cdc",

  "surfaces": [

    {

      "id": "app:@openagentsinc/acceptance-runner",

      "oracles": [

        {

          "type": "test",

          "ref": "packages/openagents-cli (44 tracked test files)"

          "ref": "packages/openagents-cli (45 tracked test files)"

        },

        {

          "type": "behavior-contract",

 * already ambiguous change shape, and a terminal that does not implement this

 * ignores it, which leaves enter doing the default and costs nothing.

 */

const PASTE_START = "\x1b[200~";

const PASTE_END = "\x1b[201~";

const KEYS_DISAMBIGUATE_ON = "\x1b[>1u";

const KEYS_DISAMBIGUATE_OFF = "\x1b[<u";

/**

 * Ask the terminal to bracket pasted text.

 *

 * Without it a paste is indistinguishable from typing, so every newline in it

 * is an enter: a twelve-line paste became twelve messages, each steering the

 * turn the one before it started. With it the terminal wraps the blob in

 * `\x1b[200~` and `\x1b[201~`, and the newlines inside are text.

 */

const BRACKETED_PASTE_ON = "\x1b[?2004h";

const BRACKETED_PASTE_OFF = "\x1b[?2004l";

const ALT_SCROLL_ON = "\x1b[?1007h";

const ALT_SCROLL_OFF = "\x1b[?1007l";

 */

const FLEET_ROWS_MAX = 8;

/** Width of the role gutter, so every entry's text starts in one column. */

const GUTTER = 9;

/**

 * Width of the marker column.

 *

 * The transcript used to name every entry down the left — `you`, `think`,

 * `coder`, `note`, `tool` — which is five words of chrome per turn saying what

 * the styling already said. What is worth a column is the one thing styling

 * cannot say: whether a reply is finished. So the column is a dot, and it is

 * two glyphs wide plus a space.

 */

const GUTTER = 4;

/**

 * How long a lone escape byte waits for the rest of a sequence.

 *

  let exitCode = 0;

  let closed = false;

  let runningSince = Date.now();

  /**

   * Which half of a second the pulse is in.

   *

   * Advanced by the same ticker that moves the elapsed clock, so an unfinished

   * reply blinks without a timer of its own.

   */

  let pulse = true;

  /** Redraws the status line once a second so the elapsed time advances. */

  let ticker: NodeJS.Timeout | undefined;

  /** Rows as last painted, so only what changed is written. */

  let viewport = 1;

  /** Bytes held back because they may be the start of an escape sequence. */

  let pendingEscape = "";

  /** A paste whose end has not arrived yet. */

  let pendingPaste = "";

  let escapeTimer: NodeJS.Timeout | undefined;

  const write = (text: string) => {

      stdout.off("resize", onResize);

      if (stdin.isTTY) stdin.setRawMode(false);

      stdin.pause();

      write(CURSOR_SHOW + KEYS_DISAMBIGUATE_OFF + ALT_SCROLL_OFF + ALT_SCREEN_OFF);

      write(

        CURSOR_SHOW + BRACKETED_PASTE_OFF + KEYS_DISAMBIGUATE_OFF + ALT_SCROLL_OFF + ALT_SCREEN_OFF,

      );

      resolve(exitCode);

    };

    };

    const renderEntry = (entry: CoderEntry, width: number): ReadonlyArray<string> => {

      const [label, color] =

      const color =

        entry.role === "you"

          ? ["you", CYAN]

          ? CYAN

          : entry.role === "assistant"

            ? ["coder", GREEN]

            ? GREEN

            : entry.role === "tool"

              ? ["tool", MAGENTA]

              ? MAGENTA

              : entry.role === "reasoning"

                ? ["think", DIM]

                : ["note", YELLOW];

      const head = `  ${color}${BOLD}${label}${RESET}${" ".repeat(GUTTER - 2 - label.length)}`;

                ? DIM

                : YELLOW;

      // A reply still arriving pulses; a finished one is solid. The dot is the

      // only thing in this column because it is the only thing the colour and

      // the styling do not already say.

      const glyph = entry.settled ? "●" : pulse ? "●" : "○";

      const head = `  ${color}${glyph}${RESET} `;

      const continuation = " ".repeat(GUTTER);

      const rows = entryRows(entry, width);

      const caret = entry.settled ? "" : `${DIM}▌${RESET}`;

      const caret = "";

      return rows.map((row, index) => {

        const tail = index === rows.length - 1 ? caret : "";

      // pushes the rule and the hints down a line and leaves the text they used

      // to occupy on screen with nothing to erase it.

      const composerRoom = Math.max(4, width - 4);

      const typed = [...composer];

      // A pasted blob is shown as what it is rather than as its last row. The

      // composer holds every line; the reader needs to know how many there are

      // and that they will go as one message, not to read them here.

      const pasted = composer.split("\n");

      const summarised =

        pasted.length > 1

          ? `${pasted[0] ?? ""} ${DIM}[+${String(pasted.length - 1)} more ${

              pasted.length === 2 ? "line" : "lines"

            }]${RESET}`

          : composer;

      const typed = [...summarised];

      const visible =

        typed.length > composerRoom

        visibleWidth(summarised) > composerRoom

          ? `…${typed.slice(typed.length - composerRoom + 1).join("")}`

          : composer;

          : summarised;

      rows.push(`  › ${visible}`);

      rows.push(rule);

      // Under the composer's own region, not inside it. Between the rules is

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

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

      }

      if (lines.length > transcriptRows) keys.push({ text: "pgup/pgdn to scroll" });

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

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

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

      const counter =

        anchor !== undefined

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

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

          : above > 0

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

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

      // The elapsed time has to advance between chunks, not only when one

      // arrives, or a slow reply looks stalled.

      // Twice a second, because the same tick drives the pulse on an unfinished

      // reply as well as the elapsed clock, and a dot that blinks once a second

      // reads as a dot that is broken.

      ticker ??= setInterval(() => {

        session.pruneTasks();

        pulse = !pulse;

        if (session.running || session.snapshot().tasks.length > 0) render();

      }, 1000);

      }, 500);

      // A delegate line is not a turn: it returns as soon as the children are

      // submitted and each one reports later, so nothing here waits on it and

        clearTimeout(escapeTimer);

        escapeTimer = undefined;

      }

      let text = pendingEscape + (typeof chunk === "string" ? chunk : chunk.toString("utf8"));

      let text =

        pendingPaste + pendingEscape + (typeof chunk === "string" ? chunk : chunk.toString("utf8"));

      pendingPaste = "";

      pendingEscape = "";

      let index = 0;

      let dirty = false;

      while (index < text.length) {

        const char = text[index] ?? "";

        // A paste is taken whole, before anything in here reads one of its

        // newlines as an enter. The terminal says where it ends; if the end has

        // not arrived yet the rest is held for the next chunk, because half a

        // paste submitted as a message is the bug this exists to stop.

        if (text.startsWith(PASTE_START, index)) {

          const from = index + PASTE_START.length;

          const to = text.indexOf(PASTE_END, from);

          if (to < 0) {

            pendingPaste = text.slice(index);

            break;

          }

          composer += text.slice(from, to);

          index = to + PASTE_END.length;

          dirty = true;

          continue;

        }

        // The skills screen takes the keyboard while it is up. Only the keys it

        // names do anything: a stray letter must not fall through into the

        // composer of a screen the reader cannot see.

    const unsubscribe = session.onChange(render);

    write(ALT_SCREEN_ON + ALT_SCROLL_ON + KEYS_DISAMBIGUATE_ON);

    write(ALT_SCREEN_ON + ALT_SCROLL_ON + KEYS_DISAMBIGUATE_ON + BRACKETED_PASTE_ON);

    if (stdin.isTTY) stdin.setRawMode(true);

    stdin.resume();

    stdin.setEncoding("utf8");

import { EventEmitter } from "node:events";

import { describe, expect, it } from "vitest";

import { CoderSession, type ReplySource } from "../src/coder-session.js";

import { runCoderUi } from "../src/coder-ui.js";

class FakeOut extends EventEmitter {

  columns = 100; rows = 24; written = "";

  write(t: string) { this.written += t; return true; }

}

class FakeIn extends EventEmitter {

  isTTY = true;

  setRawMode(){return this;} resume(){return this;} pause(){return this;} setEncoding(){return this;}

}

describe("pasting", () => {

  it("keeps a multi-line paste as one message", async () => {

    const sent: string[] = [];

    const src: ReplySource = { model: "m", async *reply(p: string) { sent.push(p); yield { type: "text", value: "ok" } as const; } };

    const stdin = new FakeIn(); const stdout = new FakeOut();

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

    const running = runCoderUi(session, { stdin: stdin as never, stdout: stdout as never });

    const ESC = String.fromCharCode(27);

    stdin.emit("data", `${ESC}[200~line one\nline two\nline three${ESC}[201~`);

    expect(sent).toEqual([]);

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

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

    expect(sent).toEqual(["line one\nline two\nline three"]);

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

  });

  it("holds a paste whose end has not arrived", async () => {

    const sent: string[] = [];

    const src: ReplySource = { model: "m", async *reply(p: string) { sent.push(p); yield { type: "text", value: "ok" } as const; } };

    const stdin = new FakeIn(); const stdout = new FakeOut();

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

    const running = runCoderUi(session, { stdin: stdin as never, stdout: stdout as never });

    const ESC = String.fromCharCode(27);

    stdin.emit("data", `${ESC}[200~first\nsec`);

    stdin.emit("data", `ond${ESC}[201~`);

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

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

    expect(sent).toEqual(["first\nsecond"]);

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

  });

  it("shows a paste as a blob rather than as its last line", async () => {

    const src: ReplySource = { model: "m", async *reply() { yield { type: "text", value: "ok" } as const; } };

    const stdin = new FakeIn(); const stdout = new FakeOut();

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

    const running = runCoderUi(session, { stdin: stdin as never, stdout: stdout as never });

    const ESC = String.fromCharCode(27);

    stdin.emit("data", `${ESC}[200~first line\nsecond\nthird${ESC}[201~`);

    // The reader needs to know how much is there and that it goes as one

    // message, not to read all of it in a one-row composer.

    const painted = stdout.written.split(new RegExp(`${ESC}\\[[0-9;]*m`)).join("");

    expect(painted).toContain("first line [+2 more lines]");

    expect(painted).not.toContain("second");

    // Ctrl+D quits only an empty composer, which is why escape comes first.

    stdin.emit("data", ESC);

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

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

  });

  it("asks the terminal to bracket pastes, and stops asking on the way out", async () => {

    const src: ReplySource = { model: "m", async *reply() { yield { type: "text", value: "ok" } as const; } };

    const stdin = new FakeIn(); const stdout = new FakeOut();

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

    const running = runCoderUi(session, { stdin: stdin as never, stdout: stdout as never });

    const ESC = String.fromCharCode(27);

    // Without this a paste is indistinguishable from typing, and every newline

    // in it is an enter.

    expect(stdout.written).toContain(`${ESC}[?2004h`);

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

    expect(stdout.written).toContain(`${ESC}[?2004l`);

  });

});

    await running;

  });

});

describe("the transcript's marker column", () => {

  const ESCAPE = String.fromCharCode(27);

  it("marks an entry with a dot rather than naming its role", async () => {

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

    const painted = rows.join("\n");

    // Five words of chrome per turn — `you`, `think`, `coder`, `note`, `tool` —

    // said what the styling already said.

    expect(painted).toContain("● an answer");

    expect(painted).not.toMatch(/\bcoder\s+an answer/);

    expect(painted).not.toMatch(/^\s*you\s/m);

  });

  it("pulses an unfinished reply and settles it when it ends", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    let release = () => {};

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

      release = resolve;

    });

    const held: ReplySource = {

      model: "scripted",

      async *reply() {

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

        await gate;

      },

    };

    const session = new CoderSession(held, "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));

    // A hollow dot is the half of the pulse that says "still arriving".

    const during = stdout.written;

    expect(during).toContain("still going");

    release();

    await turn;

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

    await running;

    expect(stdout.written).toContain("●");

  });

  it("keeps the scroll marker in the same voice as the rest of the bar", async () => {

    const { painted } = await drive(

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

        type: "text" as const,

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

      })),

    );

    // It was the one yellow word in a dim row, which read as a warning.

    expect(painted).not.toContain(`${ESCAPE}[33mscrolled`);

    // And the key it advertised is gone from the bar.

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

  });

});