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

    "filesScanned": 2467,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:2c21c17d2d8df32e49231085ac25061a9ed63bac9c4b0aae149a6904dd2972c5",

  "sourceDigest": "sha256:f11a893e45986831504d003dfa23967abb728700567e6ec3469c41b7dae7aa0f",

  "surfaces": [

    {

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

      "oracles": [

        {

          "type": "test",

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

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

        },

        {

          "type": "behavior-contract",

import { runDevinAcp } from "./coder-devin-acp.js";

import { tmpdir } from "node:os";

import { dirname, join } from "node:path";

import type { CoderTaskId, CoderTaskRegistry, CoderToolActivity } from "./coder-tasks.js";

import type {

  CoderTaskId,

  CoderTaskRegistry,

  CoderToolActivity,

  CoderToolActivityMeta,

} from "./coder-tasks.js";

/** What the console asks for. One shape whether it wants one child or fifteen. */

export interface DelegationRequest {

      readonly callId: string;

      readonly name: string;

      readonly target: string | undefined;

      /** Optional display metadata derived from the tool's input and output. */

      readonly meta?: CoderToolActivityMeta;

    }

  | { readonly type: "text"; readonly value: string }

  | { readonly type: "tokens"; readonly input: number; readonly output: number }

    const name = stringField(part, "tool") ?? "tool";

    const callId = stringField(part, "callID") ?? `${name}-${String(event["timestamp"] ?? "")}`;

    const state = isRecord(part["state"]) ? part["state"] : undefined;

    return { type: "tool", callId, name, target: toolTarget(state) };

    const { target, ...rest } = toolTarget(state);

    return { type: "tool", callId, name, target, ...rest };

  }

  if (type === "text" && part !== undefined) {

}

/**

 * What the child was working on.

 * What the child was working on, plus any display metadata the harness gave.

 *

 * The harness's own title is preferred because it is what the harness chose to

 * show; the input fields are a fallback for tools that set no title. A row that

 * says only `bash` is much less use than one that says the command.

 * show; the input fields are a fallback for tools that set no title. File

 * ranges come from `offset`/`limit` or `start`/`end`, and search hit counts come

 * from the output fields a real opencode harness uses.

 */

function toolTarget(state: Record<string, unknown> | undefined): string | undefined {

  if (state === undefined) return undefined;

type MutableToolMeta = { -readonly [K in keyof CoderToolActivityMeta]: CoderToolActivityMeta[K] };

function toolTarget(

  state: Record<string, unknown> | undefined,

): { readonly target: string | undefined; readonly meta?: CoderToolActivityMeta } {

  if (state === undefined) return { target: undefined };

  const title = stringField(state, "title");

  if (title !== undefined && title.length > 0) return title;

  const input = isRecord(state["input"]) ? state["input"] : undefined;

  if (input === undefined) return undefined;

  for (const key of ["filePath", "path", "command", "pattern", "query", "description", "url"]) {

    const value = stringField(input, key);

    if (value !== undefined && value.length > 0) return value;

  const output = isRecord(state["output"]) ? state["output"] : undefined;

  let target: string | undefined;

  if (title !== undefined && title.length > 0) {

    target = title;

  } else if (input !== undefined) {

    for (const key of ["filePath", "path", "file_path", "file", "command", "pattern", "query", "description", "url"]) {

      const value = stringField(input, key);

      if (value !== undefined && value.length > 0) {

        target = value;

        break;

      }

    }

  }

  return undefined;

  if (target === undefined) return { target: undefined };

  const meta: MutableToolMeta = {};

  if (input !== undefined) {

    const offset = numberField(input, "offset");

    const limit = numberField(input, "limit");

    const start = numberField(input, "start");

    const end = numberField(input, "end");

    if (offset !== undefined && limit !== undefined) {

      meta.range = { start: offset, end: offset + limit };

    } else if (start !== undefined && end !== undefined) {

      meta.range = { start, end };

    }

  }

  if (output !== undefined) {

    const size = numberField(output, "size") ?? numberField(output, "length");

    if (size !== undefined) meta.size = size;

    const hits =

      numberField(output, "hits") ??

      numberField(output, "hitCount") ??

      numberField(output, "total") ??

      numberField(output, "totalHits");

    if (hits !== undefined) {

      meta.hitCount = hits;

    } else {

      const matches = Array.isArray(output["matches"]) ? (output["matches"] as ReadonlyArray<unknown>).length : undefined;

      const results = Array.isArray(output["results"]) ? (output["results"] as ReadonlyArray<unknown>).length : undefined;

      if (matches !== undefined) meta.hitCount = matches;

      else if (results !== undefined) meta.hitCount = results;

    }

  }

  return Object.keys(meta).length === 0 ? { target } : { target, meta };

}

export interface OpencodeHarnessOptions {

          } else if (event.type === "tool") {

            if (counted.has(event.callId)) continue;

            counted.add(event.callId);

            const activity: CoderToolActivity = { toolName: event.name, target: event.target };

            const activity: CoderToolActivity = {

              toolName: event.name,

              target: event.target,

              ...(event.meta === undefined ? {} : { meta: event.meta }),

            };

            this.registry.recordToolUse(id, activity);

          } else if (event.type === "tokens") {

            this.registry.recordTokens(id, { input: event.input, output: event.output });

  return `${activity.toolName}${target}`;

}

/**

 * A renderer turns one tool activity into one or more bounded display rows.

 */

export type CoderActivityRenderer = (

  activity: CoderToolActivity,

  width: number,

) => ReadonlyArray<string>;

/** Show a shell or command as `name: <command>`, cut to the available width. */

const shellActivityRenderer: CoderActivityRenderer = (activity, width) => {

  if (activity.target === undefined) return [activity.toolName];

  return [cut(`${activity.toolName}: ${activity.target}`, width)];

};

/** Show a file read or write as `name: <path>:<start>-<end>` or `name: <path> (<size>)`. */

const fileActivityRenderer: CoderActivityRenderer = (activity, width) => {

  if (activity.target === undefined) return [activity.toolName];

  let body = `${activity.toolName}: ${activity.target}`;

  if (activity.meta?.range !== undefined) {

    body += `:${activity.meta.range.start}-${activity.meta.range.end}`;

  } else if (activity.meta?.size !== undefined) {

    body += ` (${activity.meta.size})`;

  }

  return [cut(body, width)];

};

/** Show a search as `name: <pattern>` plus a hit count. */

const searchActivityRenderer: CoderActivityRenderer = (activity, width) => {

  if (activity.target === undefined) return [activity.toolName];

  const hits = activity.meta?.hitCount;

  const body =

    hits === undefined

      ? `${activity.toolName}: ${activity.target}`

      : `${activity.toolName}: ${activity.target} (${hits} ${hits === 1 ? "hit" : "hits"})`;

  return [cut(body, width)];

};

/**

 * Tool-name lookup for the row renderer.

 *

 * Activity names come from the tools this session declares (shell, openagents,

 * skill, delegate) and from the child harnesses that emit them (bash, read,

 * write, edit, grep, search, repo_grep). Each name is mapped to the renderer

 * that best shows its argument.

 */

export const activityRenderers: Readonly<Record<string, CoderActivityRenderer>> = Object.freeze({

  shell: shellActivityRenderer,

  bash: shellActivityRenderer,

  read: fileActivityRenderer,

  write: fileActivityRenderer,

  edit: fileActivityRenderer,

  search: searchActivityRenderer,

  grep: searchActivityRenderer,

  repo_grep: searchActivityRenderer,

});

/**

 * The bounded, multi-row display for a single activity.

 *

 * Unregistered tools fall back to the exact one-line `activityPhrase` so the

 * fleet and the detail view stay readable for anything that shows up later.

 *

 * `taskActivity` keeps the existing one-line status phrase; surfaces that want

 * more than one row can call `activityRows` directly.

 */

export function activityRows(

  activity: CoderToolActivity,

  width: number,

): ReadonlyArray<string> {

  const renderer = activityRenderers[activity.toolName];

  if (renderer === undefined) return [activityPhrase(activity)];

  return renderer(activity, Math.max(4, width));

}

/**

 * The newest activities across a fleet, oldest first, at most `count` of them.

 *

 */

export type CoderTaskStatus = "pending" | "running" | "completed" | "failed" | "stopped";

/** Optional metadata for richer display of a tool activity. */

export interface CoderToolActivityMeta {

  /** Inclusive byte/character range for a file read or write. */

  readonly range?: { readonly start: number; readonly end: number };

  /** Size of the data read or written, in bytes or characters. */

  readonly size?: number;

  /** Number of matches for a search tool. */

  readonly hitCount?: number;

}

/** One thing a child did, in the shape a one-line status needs. */

export interface CoderToolActivity {

  readonly toolName: string;

   * then only the tool name is shown.

   */

  readonly target: string | undefined;

  /** Optional structured display metadata derived from the tool's input and output. */

  readonly meta?: CoderToolActivityMeta;

}

/** What a fleet row and a detail view read. Aggregated, never recomputed. */

    previous.progress.toolUseCount === next.progress.toolUseCount &&

    previous.progress.tokenCount === next.progress.tokenCount &&

    previous.progress.lastActivity?.toolName === next.progress.lastActivity?.toolName &&

    previous.progress.lastActivity?.target === next.progress.lastActivity?.target

    previous.progress.lastActivity?.target === next.progress.lastActivity?.target &&

    JSON.stringify(previous.progress.lastActivity?.meta) ===

      JSON.stringify(next.progress.lastActivity?.meta)

  );

}

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

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

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

import { activityRows, 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";

import type { CoderTask, CoderTaskStatus } from "./coder-tasks.js";

          // Three lines of the child's own latest activity, nested under it.

          const activities = latestActivities([task], PREVIEW_ROWS);

          for (const activity of activities) {

            const text = truncate(activityPhrase(activity), Math.max(4, width - 12));

            const rendered = activityRows(activity, Math.max(4, width - 12));

            const text = rendered[0] ?? "";

            rows.push(`${DIM}  → ${text}${RESET}`);

          }

        }

        for (const activity of activities) {

          if (rows.length + 1 > height) break;

          rows.push(`${DIM}  → ${truncate(activityPhrase(activity), inner - 4)}${RESET}`);

          const rendered = activityRows(activity, Math.max(4, inner - 4));

          const text = rendered[0] ?? "";

          rows.push(`${DIM}  → ${text}${RESET}`);

        }

        rows.push("");

    expect(parseOpencodeEvent(line)).toMatchObject({ name: "bash", target: "pnpm test" });

  });

  it("extracts a file range from offset and limit", () => {

    const line = JSON.stringify({

      type: "tool_use",

      part: {

        tool: "read",

        callID: "call-range",

        state: { input: { filePath: "src/a.ts", offset: 10, limit: 40 } },

      },

    });

    expect(parseOpencodeEvent(line)).toMatchObject({

      name: "read",

      target: "src/a.ts",

      meta: { range: { start: 10, end: 50 } },

    });

  });

  it("extracts a file size from output", () => {

    const line = JSON.stringify({

      type: "tool_use",

      part: {

        tool: "read",

        callID: "call-size",

        state: { input: { filePath: "src/b.ts" }, output: { size: 240 } },

      },

    });

    expect(parseOpencodeEvent(line)).toMatchObject({

      name: "read",

      target: "src/b.ts",

      meta: { size: 240 },

    });

  });

  it("extracts a search hit count from output", () => {

    const line = JSON.stringify({

      type: "tool_use",

      part: {

        tool: "grep",

        callID: "call-hits",

        state: { input: { pattern: "needle" }, output: { matches: [1, 2, 3] } },

      },

    });

    expect(parseOpencodeEvent(line)).toMatchObject({

      name: "grep",

      target: "needle",

      meta: { hitCount: 3 },

    });

  });

  it("reads text and token usage", () => {

    expect(parseOpencodeEvent('{"type":"text","part":{"text":"banana"}}')).toEqual({

      type: "text",

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

import { activityPhrase, activityRenderers, activityRows } from "../src/coder-fleet.js";

describe("activity rows", () => {

  it("shows a shell command, truncated to the width", () => {

    expect(activityRows({ toolName: "bash", target: "pnpm test" }, 40)).toEqual([

      "bash: pnpm test",

    ]);

    expect(activityRows({ toolName: "shell", target: "pnpm build" }, 40)).toEqual([

      "shell: pnpm build",

    ]);

    const long = "a".repeat(200);

    const rows = activityRows({ toolName: "bash", target: long }, 20);

    expect(rows).toHaveLength(1);

    expect([...rows[0]!].length).toBeLessThanOrEqual(20);

    expect(rows[0]).toMatch(/^bash: /);

    expect(rows[0]).toMatch(/…$/);

  });

  it("shows a file path for read, write, and edit", () => {

    expect(activityRows({ toolName: "read", target: "src/a.ts" }, 40)).toEqual([

      "read: src/a.ts",

    ]);

    expect(activityRows({ toolName: "write", target: "src/b.ts" }, 40)).toEqual([

      "write: src/b.ts",

    ]);

    expect(activityRows({ toolName: "edit", target: "src/c.ts" }, 40)).toEqual([

      "edit: src/c.ts",

    ]);

    const long = "packages/openagents-cli/src/some/very/deep/file.ts";

    const rows = activityRows({ toolName: "read", target: long }, 20);

    expect(rows).toHaveLength(1);

    expect([...rows[0]!].length).toBeLessThanOrEqual(20);

  });

  it("shows a search pattern", () => {

    expect(activityRows({ toolName: "grep", target: "needle" }, 40)).toEqual(["grep: needle"]);

    expect(activityRows({ toolName: "search", target: "term" }, 40)).toEqual(["search: term"]);

    expect(activityRows({ toolName: "repo_grep", target: "pattern" }, 40)).toEqual([

      "repo_grep: pattern",

    ]);

    const long = "a very long search pattern that needs cutting";

    const rows = activityRows({ toolName: "grep", target: long }, 20);

    expect(rows).toHaveLength(1);

    expect([...rows[0]!].length).toBeLessThanOrEqual(20);

  });

  it("leaves the tool name alone when there is no target", () => {

    expect(activityRows({ toolName: "bash", target: undefined }, 40)).toEqual(["bash"]);

    expect(activityRows({ toolName: "read", target: undefined }, 40)).toEqual(["read"]);

    expect(activityRows({ toolName: "grep", target: undefined }, 40)).toEqual(["grep"]);

  });

  it("falls back to the exact activityPhrase for an unregistered tool", () => {

    const withTarget = { toolName: "think", target: "deeply" };

    expect(activityRows(withTarget, 80)).toEqual([activityPhrase(withTarget)]);

    const noTarget = { toolName: "unknown", target: undefined };

    expect(activityRows(noTarget, 80)).toEqual([activityPhrase(noTarget)]);

  });

  it("exposes the same renderer under harness aliases", () => {

    expect(activityRenderers["bash"]).toBe(activityRenderers["shell"]);

    expect(activityRenderers["write"]).toBe(activityRenderers["edit"]);

    expect(activityRenderers["grep"]).toBe(activityRenderers["search"]);

    expect(activityRenderers["repo_grep"]).toBe(activityRenderers["search"]);

  });

  it("shows a file read with a range", () => {

    expect(

      activityRows({ toolName: "read", target: "src/a.ts", meta: { range: { start: 10, end: 50 } } }, 40),

    ).toEqual(["read: src/a.ts:10-50"]);

  });

  it("shows a file write with a size", () => {

    expect(

      activityRows({ toolName: "write", target: "src/b.ts", meta: { size: 240 } }, 40),

    ).toEqual(["write: src/b.ts (240)"]);

  });

  it("shows a search with a hit count", () => {

    expect(

      activityRows({ toolName: "grep", target: "needle", meta: { hitCount: 3 } }, 40),

    ).toEqual(["grep: needle (3 hits)"]);

    expect(

      activityRows({ toolName: "search", target: "term", meta: { hitCount: 1 } }, 40),

    ).toEqual(["search: term (1 hit)"]);

    expect(

      activityRows({ toolName: "repo_grep", target: "pattern", meta: { hitCount: 0 } }, 40),

    ).toEqual(["repo_grep: pattern (0 hits)"]);

  });

  it("cuts a file or search with metadata to the given width", () => {

    const long = "packages/openagents-cli/src/some/very/deep/file.ts";

    const withRange = activityRows(

      { toolName: "read", target: long, meta: { range: { start: 0, end: 100 } } },

      20,

    );

    expect(withRange).toHaveLength(1);

    expect([...withRange[0]!].length).toBeLessThanOrEqual(20);

    expect(withRange[0]).toMatch(/^read: /);

  });

});

    const previews = rows.slice(childRow + 1, childRow + 4);

    expect(previews).toHaveLength(3);

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

    expect(text).toContain("shell(mix test)");

    expect(text).toContain("edit(src/b.ts)");

    expect(text).toContain("bash(pnpm test)");

    expect(text).toContain("shell: mix test");

    expect(text).toContain("edit: src/b.ts");

    expect(text).toContain("bash: pnpm test");

    // Pushed out by the newer work.

    expect(text).not.toContain("read(src/a.ts)");

    expect(text).not.toContain("grep(needle)");

    expect(text).not.toContain("read: src/a.ts");

    expect(text).not.toContain("grep: needle");

    // Newest last, so reading down is reading forward in time.

    const at = (phrase: string) => previews.findIndex((row) => row.includes(phrase));

    expect(at("bash(pnpm test)")).toBeLessThan(at("edit(src/b.ts)"));

    expect(at("edit(src/b.ts)")).toBeLessThan(at("shell(mix test)"));

    expect(at("bash: pnpm test")).toBeLessThan(at("edit: src/b.ts"));

    expect(at("edit: src/b.ts")).toBeLessThan(at("shell: mix test"));

  });

  it("draws no preview until the child has done something", async () => {