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

    "filesScanned": 2440,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:b66f940c59b2d89100cc77723ed92cd43247cc8b3b868330a5c2d39cdb6b33d9",

  "sourceDigest": "sha256:534cff090b222b33201687df5e82e45eb96b388e9dfe03bacd0b360e0e737184",

  "surfaces": [

    {

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

      "oracles": [

        {

          "type": "test",

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

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

        },

        {

          "type": "behavior-contract",

 * wrong. A running child with no activity yet says `Initializing…` rather than

 * nothing, because an empty cell reads as a stalled child.

 */

export function taskActivity(task: CoderTask): string {

export function taskActivity(task: CoderTask, now: number = Date.now()): string {

  if (task.status === "pending") return "Queued";

  if (task.status === "stopped") return "Stopped";

  if (task.status === "failed") return `Failed: ${collapse(task.error ?? "unknown error")}`;

    return `Done (${cost})`;

  }

  // A running child says how long it has been running, because the reader's

  // question is never "what is it doing" alone — it is "is this slow or is it

  // stuck". A recon child that thinks for ninety seconds before its first tool

  // call showed `Initializing…` for all ninety, which reads as stuck.

  const running = formatDuration(now - task.startedAt);

  const activity = task.progress.lastActivity;

  if (activity === undefined) return "Initializing…";

  if (activity === undefined) return `Initializing… (${running})`;

  const target = activity.target === undefined ? "" : `(${collapse(activity.target)})`;

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

  return `${activity.toolName}${target} (${running})`;

}

/**

 * lines up, which is what lets a reader scan fifteen children for the one that

 * failed.

 */

export function fleetRows(tasks: ReadonlyArray<CoderTask>, width: number): ReadonlyArray<FleetRow> {

export function fleetRows(

  tasks: ReadonlyArray<CoderTask>,

  width: number,

  now: number = Date.now(),

): ReadonlyArray<FleetRow> {

  const room = Math.max(20, width);

  const descriptionRoom = Math.min(28, Math.max(12, Math.floor(room * 0.35)));

  const longest = tasks.reduce((most, task) => Math.max(most, task.description.length), 0);

    const branch = index === tasks.length - 1 ? "└─" : "├─";

    const description = pad(cut(task.description, column), column);

    const counters = taskCounters(task);

    const activity = taskActivity(task);

    const activity = taskActivity(task, now);

    const tail = counters.length > 0 ? `${activity} · ${counters}` : activity;

    return {

      status: task.status,

/**

 * Run several event streams at once and yield what they produce as it arrives.

 *

 * A model that asks for two tools in one turn is saying they do not depend on

 * each other. Running them in order anyway made a session that fanned out to two

 * models take the sum of both — three minutes and thirty-eight seconds, then

 * eleven — and report that they had run in parallel, which was the reasonable

 * thing to believe and not true.

 *

 * Order within one stream is preserved, because a tool call and its result are

 * a sequence. Order between streams is arrival order, which is the point.

 */

export async function* merge<T>(

  streams: ReadonlyArray<AsyncIterable<T>>,

): AsyncIterable<T> {

  if (streams.length === 0) return;

  if (streams.length === 1) {

    yield* streams[0] as AsyncIterable<T>;

    return;

  }

  const queue: T[] = [];

  let live = streams.length;

  let failure: unknown;

  let wake: (() => void) | undefined;

  const nudge = () => {

    wake?.();

    wake = undefined;

  };

  for (const stream of streams) {

    void (async () => {

      try {

        for await (const item of stream) {

          queue.push(item);

          nudge();

        }

      } catch (cause) {

        // The first failure is kept and raised once every stream has stopped:

        // a tool that threw must not strand the others mid-flight, and a caller

        // that saw half a turn's events and no error would report a turn that

        // did not happen.

        failure ??= cause;

      } finally {

        live -= 1;

        nudge();

      }

    })();

  }

  while (live > 0 || queue.length > 0) {

    while (queue.length > 0) {

      const next = queue.shift();

      if (next !== undefined) yield next;

    }

    if (live === 0) break;

    await new Promise<void>((resolve) => {

      wake = resolve;

    });

  }

  if (failure !== undefined) throw failure;

}

import { Ollama } from "ollama";

import type { Message as OllamaMessage, Tool as OllamaTool, ToolCall as OllamaToolCall } from "ollama";

import { merge } from "./coder-merge.js";

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

import type { CoderTool } from "./coder-tools.js";

      if (calls.length === 0) return;

      for (const call of calls) {

        if (signal.aborted) return;

        yield* this.invoke(call, signal);

      }

      // Concurrently. A model asking for two tools in one turn is saying they do

      // not depend on each other, and running them in order anyway makes a fan-out

      // to two models cost the sum of both.

      if (signal.aborted) return;

      yield* merge(calls.map((call) => this.invoke(call, signal)));

    }

import { Redacted } from "effect";

import type { ChildGrant } from "./coder-child-gateway.js";

import { merge } from "./coder-merge.js";

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

import type { CoderTool } from "./coder-tools.js";

          continue;

        }

        for (const call of calls) {

          if (signal.aborted) return;

          yield* this.invoke(call, signal);

        }

        // Concurrently. A model asking for two tools in one turn is saying they do

        // not depend on each other, and running them in order anyway makes a fan-out

        // to two models cost the sum of both.

        if (signal.aborted) return;

        yield* merge(calls.map((call) => this.invoke(call, signal)));

      }

    } finally {

      // Read the budget on the way out of every turn, including an interrupted

    const running = registry.list()[0];

    expect(running).toBeDefined();

    if (running === undefined) return;

    expect(taskActivity(running)).toBe("bash(pnpm test)");

    // A running child says how long it has been running, so the reader can

    // tell a slow child from a stuck one.

    const now = running.startedAt + 95_000;

    expect(taskActivity(running, now)).toBe("bash(pnpm test) (1m 35s)");

    expect(fleetPhrase([running])).toBe("1 agent");

    const rows = fleetRows([running], 80);

    const rows = fleetRows([running], 80, now);

    expect(rows[0]?.branch).toBe("└─");

    expect(rows[0]?.mark).toBe("◐");

    expect(rows[0]?.text).toContain("bash(pnpm test)");

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

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

const after = (ms: number, ...items: string[]): AsyncIterable<string> => ({

  async *[Symbol.asyncIterator]() {

    for (const item of items) {

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

      yield item;

    }

  },

});

describe("running streams together", () => {

  it("yields in arrival order, not in the order the streams were given", async () => {

    const seen: string[] = [];

    for await (const item of merge([after(40, "slow"), after(5, "fast")])) seen.push(item);

    // The whole point: a fan-out to two models should cost the slower of the

    // two rather than the sum.

    expect(seen).toEqual(["fast", "slow"]);

  });

  it("takes the time of the slowest, not the total", async () => {

    const started = Date.now();

    for await (const _ of merge([after(60, "a"), after(60, "b"), after(60, "c")])) void _;

    expect(Date.now() - started).toBeLessThan(150);

  });

  it("keeps each stream's own order", async () => {

    const seen: string[] = [];

    for await (const item of merge([after(10, "1", "2", "3")])) seen.push(item);

    // A tool call and its result are a sequence, whatever else is running.

    expect(seen).toEqual(["1", "2", "3"]);

  });

  it("lets the others finish before it raises a failure", async () => {

    const angry: AsyncIterable<string> = {

      // eslint-disable-next-line require-yield -- it only throws

      async *[Symbol.asyncIterator]() {

        throw new Error("tool exploded");

      },

    };

    const seen: string[] = [];

    await expect(

      (async () => {

        for await (const item of merge([angry, after(20, "survivor")])) seen.push(item);

      })(),

    ).rejects.toThrow("tool exploded");

    // A tool that threw must not strand the others mid-flight.

    expect(seen).toEqual(["survivor"]);

  });

  it("passes a single stream straight through", async () => {

    const seen: string[] = [];

    for await (const item of merge([after(1, "only")])) seen.push(item);

    expect(seen).toEqual(["only"]);

  });

});