"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": 2457,

    "filesScanned": 2458,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:3efa9aed58a255fc524c7fb0c01478b9eb7afaf93cc50ffa7baddacd4590c65d",

  "sourceDigest": "sha256:d492fe3229c64f1d4b8d114ab4ed45bef787f8e7fc2277927d6b9d60491c4ee2",

  "surfaces": [

    {

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

      "oracles": [

        {

          "type": "test",

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

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

        },

        {

          "type": "behavior-contract",

/**

 * A tool call in one line, for the row that names it.

 *

 * A collapsed call took three rows: the tool's name, its arguments as raw

 * JSON, and its result. The middle row is the one nobody reads as JSON —

 * `{"args":["issue","view","212","-R","OpenAgentsInc/openagents.com"]}` is a

 * command line wearing a costume, and eight of them in a row is a screen of

 * punctuation with the answers pushed off the bottom.

 *

 * So the call joins the row that names it, in the shape a person would have

 * typed: `openagents issue view 212 -R OpenAgentsInc/openagents.com`. The raw

 * arguments are still there under `ctrl+o`, which is what expanding a call is

 * for.

 *

 * Nothing here invents a summary it cannot make. A tool whose arguments have no

 * obvious subject falls back to the JSON, clipped by the caller, which is what

 * the row showed before.

 */

/** Fields worth showing whole, in the order a tool would mean them. */

const SUBJECTS = ["command", "path", "file", "pattern", "query", "name"] as const;

export const summarizeToolCall = (args: string): string => {

  const trimmed = args.trim();

  if (trimmed.length === 0) return "";

  let parsed: unknown;

  try {

    parsed = JSON.parse(trimmed);

  } catch {

    // Arguments still streaming in, or a tool that never sent JSON. The raw

    // text is better than nothing and the caller clips it.

    return trimmed;

  }

  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return trimmed;

  const record = parsed as Record<string, unknown>;

  // An argument vector, which is the case this exists for: the `openagents`

  // tool takes the command line as a list, and joining it back is the whole

  // translation.

  const vector = record["args"];

  if (Array.isArray(vector) && vector.every((part) => typeof part === "string")) {

    return (vector as ReadonlyArray<string>).map(quote).join(" ");

  }

  for (const key of SUBJECTS) {

    const value = record[key];

    if (typeof value === "string" && value.length > 0) return value;

  }

  // Nothing named. Keep every field, without the JSON punctuation that made

  // the row unreadable.

  const pairs = Object.entries(record).filter(([, value]) => value !== undefined);

  if (pairs.length === 0) return "";

  return pairs.map(([key, value]) => `${key}=${scalar(value)}`).join(" ");

};

/**

 * A shell-style quote, so a line with a space in it still reads as one

 * argument rather than as two.

 */

const quote = (part: string): string =>

  part.length === 0 || /[\s"']/.test(part) ? JSON.stringify(part) : part;

const scalar = (value: unknown): string => {

  if (typeof value === "string") return quote(value);

  if (typeof value === "number" || typeof value === "boolean") return String(value);

  return JSON.stringify(value);

};

 */

import { readChildTranscript } from "./coder-child-transcript.js";

import { summarizeToolCall } from "./coder-tool-summary.js";

import { activityPhrase, fleetRows, latestActivities, taskActivity } from "./coder-fleet.js";

import { renderMarkdown, visibleWidth, wrapStyled } from "./coder-markdown.js";

import type { CoderEntry, CoderSession, CoderSnapshot, CoderToolCall } from "./coder-session.js";

          : tool.status === "failed"

            ? `${RED}✗${RESET}`

            : `${GREEN}✓${RESET}`;

      const rows = [`${mark} ${BOLD}${tool.name}${RESET}`];

      // The call on the row that names it, in the shape a person would have

      // typed. It used to sit below as raw JSON, which cost a row per call and

      // read as punctuation; `ctrl+o` still shows the arguments whole.

      const summary = clip(

        summarizeToolCall(tool.arguments),

        Math.max(8, width - tool.name.length - 4),

      );

      const rows = [

        `${mark} ${BOLD}${tool.name}${RESET}` + (summary.length === 0 ? "" : ` ${DIM}${summary}${RESET}`),

      ];

      if (tool.name === "delegate" && tool.status === "running") {

        // Working children first when there are more than fit: a finished child

      }

      if (tool.name !== "delegate" || tool.status !== "running") {

        const args = clip(tool.arguments, Math.max(8, width - 4));

        if (args.length > 0) rows.push(`${DIM}${args}${RESET}`);

        const outcome =

          tool.error !== undefined

            ? `${RED}${clip(tool.error, Math.max(8, width - 4))}${RESET}`

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

import { summarizeToolCall } from "../src/coder-tool-summary.js";

describe("a tool call in one line", () => {

  it("turns an argument vector back into the command line it was", () => {

    // The case this exists for. Eight of these in a row was a screen of

    // punctuation with the answers pushed off the bottom.

    expect(

      summarizeToolCall(`{"args":["issue","view","212","-R","OpenAgentsInc/openagents.com"]}`),

    ).toBe("issue view 212 -R OpenAgentsInc/openagents.com");

  });

  it("quotes an argument with a space, so it still reads as one", () => {

    expect(summarizeToolCall(`{"args":["issue","create","--title","two words"]}`)).toBe(

      `issue create --title "two words"`,

    );

  });

  it("shows a command as the command", () => {

    expect(summarizeToolCall(`{"command":"ls -la docs/"}`)).toBe("ls -la docs/");

  });

  it("prefers the subject over the tool's other settings", () => {

    // `timeout_seconds` is a knob; the command is what the reader is reading

    // for.

    expect(summarizeToolCall(`{"timeout_seconds":600,"command":"pnpm test"}`)).toBe("pnpm test");

  });

  it("names a skill, a path, and a pattern", () => {

    expect(summarizeToolCall(`{"name":"superdelegate"}`)).toBe("superdelegate");

    expect(summarizeToolCall(`{"path":"lib/a.ex"}`)).toBe("lib/a.ex");

    expect(summarizeToolCall(`{"pattern":"needle"}`)).toBe("needle");

  });

  it("drops the punctuation when nothing is named", () => {

    // `delegate` has no single subject, and its fields are still what a reader

    // wants: how many children, and what they were asked for.

    expect(summarizeToolCall(`{"count":3,"description":"audit the providers"}`)).toBe(

      `count=3 description="audit the providers"`,

    );

  });

  it("says nothing for a call with no arguments", () => {

    expect(summarizeToolCall("{}")).toBe("");

    expect(summarizeToolCall("")).toBe("");

  });

  it("keeps the raw text while the arguments are still arriving", () => {

    // A call streams in a fragment at a time, so half of it is not JSON yet.

    // The row shows what there is rather than going blank and back.

    expect(summarizeToolCall(`{"command":"ls -`)).toBe(`{"command":"ls -`);

  });

});

    expect(rows.join("\n")).not.toContain("connected:Here");

  });

  it("shows the tool name, its arguments, and its outcome", async () => {

  it("shows the tool, its call, and its outcome, on two rows", async () => {

    const { rows } = await drive([

      { type: "tool_call", callId: "c1", name: "repo_grep", arguments: '{"pattern":"x"}' },

      { type: "tool_result", callId: "c1", output: '{"matches":[]}', error: undefined },

    ]);

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

    expect(text).toContain("repo_grep");

    expect(text).toContain('{"pattern":"x"}');

    expect(text).toContain('{"matches":[]}');

    // The call joins the row that names it. It used to sit below as raw JSON,

    // which cost a row per call and read as punctuation rather than as the

    // command it is.

    const named = rows.find((row) => row.includes("repo_grep")) ?? "";

    expect(named).toContain("repo_grep x");

    expect(named).not.toContain('{"pattern"');

    expect(rows.join("\n")).toContain('{"matches":[]}');

  });

  it("shows an argument vector as the command line it is", async () => {

    const { rows } = await drive([

      {

        type: "tool_call",

        callId: "c1",

        name: "openagents",

        arguments: '{"args":["issue","view","212","-R","OpenAgentsInc/openagents.com"]}',

      },

      { type: "tool_result", callId: "c1", output: "#212 Rename the API", error: undefined },

    ]);

    const named = rows.find((row) => row.includes("openagents")) ?? "";

    expect(named).toContain("openagents issue view 212 -R OpenAgentsInc/openagents.com");

  });

  it("renders assistant Markdown rather than its source", async () => {