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

    "filesScanned": 2453,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:609044b7941afd31bd1343035391f97c9863c1c42c3419eecc2ebc4d4a68d585",

  "sourceDigest": "sha256:ac35b91f0360afc7210b7c55d483e80298724af060859b7f702fba112d503937",

  "surfaces": [

    {

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

      "oracles": [

        {

          "type": "test",

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

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

        },

        {

          "type": "behavior-contract",

import { rebuild, RELOAD_EXIT_CODE, sourceCheckout } from "./coder-reload.js";

import { loadSkillSelection, standingContext } from "./coder-skills.js";

import { startDevServer } from "./coder-dev-server.js";

import { describeWorkspace } from "./coder-workspace.js";

import { ComputerClient } from "./computer-client.js";

import { ComputerUp } from "./computer-up.js";

      );

      if (dev) {

        const reachable = yield* Effect.promise(async () => {

          try {

            const answer = await fetch(new URL("/healthz", endpoint.origin), {

              signal: AbortSignal.timeout(1_500),

            });

            return answer.ok;

          } catch {

            return false;

          }

        });

        // Started rather than asked for. `--dev` exists to remove a wait, and

        // telling the reader to go and start a server puts a second wait in

        // front of the first.

        const boot = yield* Effect.promise(() =>

          startDevServer(endpoint.origin, {

            notice: (message) => {

              process.stderr.write(`${message}\n`);

            },

          }),

        );

        if (!reachable) {

          return yield* new InputError({

            message:

              `No development server is answering at ${endpoint.origin}. ` +

              "Start it with `mix phx.server` in the openagents.com checkout, or drop --dev.",

          });

        if (boot.refusal !== undefined) {

          return yield* new InputError({ message: boot.refusal });

        }

        if (boot.started) process.stderr.write(`Dev server ready at ${endpoint.origin}.\n`);

      }

      // A `--model` value that starts with `ollama:` goes to the local Ollama

import { spawn } from "node:child_process";

import { existsSync, openSync, readFileSync } from "node:fs";

import { homedir, tmpdir } from "node:os";

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

/**

 * Starting and waiting on the `openagents.com` development server for `--dev`.

 *

 * `--dev` exists because a deploy can take half an hour. Telling the reader to

 * go and start a server themselves puts a second wait in front of the first

 * one, so this starts it: a session that asks for the dev lane gets the dev

 * lane, and the only thing it has to be told is which log to read if the server

 * does not come up.

 *

 * The server is left running when the session ends. It compiles on boot and

 * that cost is worth paying once rather than once per session, and a reader who

 * wants it gone knows where it is.

 */

/** Where the server's output goes, so a failed boot can be read rather than guessed at. */

export const devServerLog = (): string => join(tmpdir(), "openagents-dev-server.log");

/**

 * The `openagents.com` checkout to start a server from.

 *

 * Walks up from the working directory first, so a session already inside the

 * repository starts that copy rather than one somewhere else on the machine.

 * `OPENAGENTS_COM_PATH` overrides for a checkout in neither place.

 */

export const findSiteCheckout = (

  from: string = process.cwd(),

  env: NodeJS.ProcessEnv = process.env,

): string | undefined => {

  const named = env["OPENAGENTS_COM_PATH"];

  if (named !== undefined && isSiteCheckout(named)) return resolve(named);

  for (let path = resolve(from); ; path = dirname(path)) {

    if (isSiteCheckout(path)) return path;

    if (dirname(path) === path) break;

  }

  const beside = join(homedir(), "work", "openagents.com");

  return isSiteCheckout(beside) ? beside : undefined;

};

/**

 * Whether this directory is the Phoenix application rather than some other Mix

 * project. Read from `mix.exs`, because a directory named `openagents.com` that

 * is not the app would fail later and less clearly.

 */

const isSiteCheckout = (path: string): boolean => {

  const manifest = join(path, "mix.exs");

  if (!existsSync(manifest)) return false;

  try {

    return /app:\s*:openagents\b/.test(readFileSync(manifest, "utf8"));

  } catch {

    return false;

  }

};

/** What `/healthz` says: serving, needs migrations, or not answering. */

type Health = "ok" | "pending_migrations" | "down";

const health = async (origin: string, timeoutMs = 1_500): Promise<Health> => {

  try {

    const answer = await fetch(new URL("/healthz", origin), {

      signal: AbortSignal.timeout(timeoutMs),

    });

    const body = await answer.text();

    if (answer.ok && body.includes(`"status"`)) return "ok";

    // Phoenix serves the pending-migration error as its own debug page, which

    // is a live server that cannot answer yet rather than a dead one.

    return body.includes("PendingMigrationError") ? "pending_migrations" : "down";

  } catch {

    return "down";

  }

};

/** Whether a server is already serving at this origin. */

export const devServerReady = async (origin: string): Promise<boolean> =>

  (await health(origin)) === "ok";

const run = (command: string, args: readonly string[], cwd: string, log: number) =>

  new Promise<number>((settle) => {

    const child = spawn(command, args, {

      cwd,

      stdio: ["ignore", log, log],

      env: { ...process.env, MIX_ENV: "dev" },

    });

    child.on("close", (code) => settle(code ?? 1));

    child.on("error", () => settle(1));

  });

export interface DevServerStart {

  readonly started: boolean;

  /** Why it could not be started, for a reader who has to act on it. */

  readonly refusal?: string;

}

/**

 * Bring a development server up at this origin, or report why not.

 *

 * Already serving is success and starts nothing. Otherwise it starts one in the

 * checkout it finds, migrates when the server says its database is behind, and

 * waits for `/healthz` to answer — a first boot compiles, so the wait is long

 * and says so rather than looking like a hang.

 */

export const startDevServer = async (

  origin: string,

  options: {

    readonly notice?: (message: string) => void;

    readonly timeoutMs?: number;

    readonly cwd?: string;

  } = {},

): Promise<DevServerStart> => {

  const notice = options.notice ?? (() => undefined);

  const deadline = Date.now() + (options.timeoutMs ?? 240_000);

  const current = await health(origin);

  if (current === "ok") return { started: false };

  const checkout = findSiteCheckout(options.cwd);

  if (checkout === undefined) {

    return {

      started: false,

      refusal:

        `No development server is answering at ${origin}, and no openagents.com ` +

        "checkout was found to start one from. Set OPENAGENTS_COM_PATH to it, or drop --dev.",

    };

  }

  const logPath = devServerLog();

  const log = openSync(logPath, "a");

  // A server that is up but refusing every request because its database is

  // behind is one migration away from working, and running it is what a person

  // would do next anyway.

  if (current === "pending_migrations") {

    notice("The dev server's database is behind. Migrating.");

    await run("mix", ["ecto.migrate"], checkout, log);

    if (await devServerReady(origin)) return { started: true };

  }

  notice(`Starting a dev server in ${checkout}. First boot compiles, so this can take a minute.`);

  // Detached, so the server outlives this session: the next `--dev` finds it

  // already up and pays no boot cost at all.

  const server = spawn("mix", ["phx.server"], {

    cwd: checkout,

    stdio: ["ignore", log, log],

    detached: true,

    env: { ...process.env, MIX_ENV: "dev" },

  });

  server.unref();

  let migrated = false;

  for (;;) {

    if (Date.now() > deadline) {

      return {

        started: false,

        refusal:

          `A dev server was started in ${checkout} but did not answer at ${origin} in time. ` +

          `Its output is in ${logPath}.`,

      };

    }

    await new Promise((wake) => setTimeout(wake, 1_000));

    const state = await health(origin);

    if (state === "ok") return { started: true };

    if (state === "pending_migrations" && !migrated) {

      migrated = true;

      notice("The dev server's database is behind. Migrating.");

      await run("mix", ["ecto.migrate"], checkout, log);

    }

  }

};

import { mkdirSync, mkdtempSync, writeFileSync } from "node:fs";

import { tmpdir } from "node:os";

import { join } from "node:path";

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

import { devServerReady, findSiteCheckout, startDevServer } from "../src/coder-dev-server.js";

/** A directory tree with a Phoenix `mix.exs` at its root. */

const siteCheckout = () => {

  const root = mkdtempSync(join(tmpdir(), "oa-site-"));

  writeFileSync(join(root, "mix.exs"), "def project do\n  [app: :openagents, version: \"0.1.0\"]\nend\n");

  mkdirSync(join(root, "lib", "openagents_web"), { recursive: true });

  return root;

};

afterEach(() => {

  vi.unstubAllGlobals();

});

describe("finding the checkout to start a server from", () => {

  it("takes the checkout the session is already inside, from any depth", () => {

    const root = siteCheckout();

    expect(findSiteCheckout(join(root, "lib", "openagents_web"), {})).toBe(root);

  });

  it("prefers an explicitly named checkout over the search", () => {

    const named = siteCheckout();

    const inside = siteCheckout();

    expect(findSiteCheckout(inside, { OPENAGENTS_COM_PATH: named })).toBe(named);

  });

  it("ignores a named path that is not the application", () => {

    const root = siteCheckout();

    // Falls through to the search rather than starting `mix` somewhere that

    // will fail a minute later and less clearly.

    expect(findSiteCheckout(root, { OPENAGENTS_COM_PATH: mkdtempSync(join(tmpdir(), "oa-not-")) })).toBe(

      root,

    );

  });

  it("does not take a Mix project that is some other application", () => {

    const other = mkdtempSync(join(tmpdir(), "oa-other-"));

    writeFileSync(join(other, "mix.exs"), "def project do\n  [app: :something_else]\nend\n");

    // Not this one: the fallback may still find the real checkout on the

    // machine, but it must not have chosen the wrong Mix project.

    expect(findSiteCheckout(other, {})).not.toBe(other);

  });

});

describe("readiness", () => {

  const stub = (answer: () => Response | Promise<Response>) =>

    vi.stubGlobal("fetch", vi.fn(answer));

  it("counts a serving health endpoint as ready", async () => {

    stub(() => new Response(JSON.stringify({ status: "ok", revision: "image" }), { status: 200 }));

    expect(await devServerReady("http://localhost:4000")).toBe(true);

  });

  it("does not count a server whose database is behind as ready", async () => {

    // Phoenix answers this as its own debug page, so it is a live server that

    // cannot serve yet — neither ready nor absent.

    stub(() => new Response("<html>Phoenix.Ecto.PendingMigrationError at GET /healthz</html>", { status: 500 }));

    expect(await devServerReady("http://localhost:4000")).toBe(false);

  });

  it("does not count an unreachable server as ready", async () => {

    stub(() => {

      throw new Error("ECONNREFUSED");

    });

    expect(await devServerReady("http://localhost:4000")).toBe(false);

  });

});

describe("starting one", () => {

  it("starts nothing when a server is already serving", async () => {

    vi.stubGlobal(

      "fetch",

      vi.fn(() => new Response(JSON.stringify({ status: "ok" }), { status: 200 })),

    );

    const said: string[] = [];

    const result = await startDevServer("http://localhost:4000", {

      notice: (message) => said.push(message),

    });

    expect(result).toEqual({ started: false });

    // Nothing announced, because nothing happened: the warm path is the common

    // one and should be silent.

    expect(said).toEqual([]);

  });

});