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

    "filesScanned": 2433,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:5ecdc0a7a3a28075c8356671025554ef9c69e4cdc9c25e80eb9b6377bfb567af",

  "sourceDigest": "sha256:4850da44cf6c8cacbc5ec66d9405156d05c9008aed2fd97dbe17d9492041dec8",

  "surfaces": [

    {

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

      "oracles": [

        {

          "type": "test",

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

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

        },

        {

          "type": "behavior-contract",

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

import { openThread, ThreadUnavailable, type ThreadReplySource } from "./coder-thread.js";

import { delegateTool, skillTool } from "./coder-tools.js";

import { spawnSync } from "node:child_process";

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

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

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

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

        }

      });

      // The interface asks for a restart by exiting with a code of its own. It

      // is done here rather than there because the rebuild has to happen after

      // the screen is given back: a compiler writing over a live alt-screen is

      // a session the reader cannot read.

      if (code === RELOAD_EXIT_CODE) {

        const root = sourceCheckout();

        if (root !== undefined) {

          const built = rebuild(root);

          if (built.ok) {

            const restarted = spawnSync(process.execPath, process.argv.slice(1), {

              stdio: "inherit",

            });

            process.exitCode = restarted.status ?? 0;

            return;

          }

          // The compiler's own words, and the old session is not resumed: a

          // reload onto code that does not build would be a reload onto the

          // build before it, silently.

          process.stderr.write(`${built.output}\n\nReload failed: the build did not pass.\n`);

          process.exitCode = 1;

          return;

        }

      }

      if (code !== 0) {

        process.exitCode = code;

      }

import { createInterface } from "node:readline";

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

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

import type { SkillSelection } from "./coder-skills.js";

export interface CoderPlainOptions {

  const unsubscribe = session.onChange(flush);

  flush();

  /** Set when `/reload` asks the runner to rebuild and start again. */

  let reloading = false;

  const answer = async (line: string) => {

    // The same command as in the interface, and the same division of labour:

    // this only asks, and the runner rebuilds once it has the terminal back.

    if (/^\/reload\s*$/.test(line.trim())) {

      if (sourceCheckout() === undefined) {

        stdout.write(

          "\nThis session is not running from a source checkout, so there is nothing to rebuild.\n",

        );

        return;

      }

      reloading = true;

      return;

    }

    // `/skills` is a screen in the interface. There is no screen here, so it

    // reports instead: the same facts, without the switch. Saying nothing and

    // sending it to the model as a question would be worse than either.

  try {

    if (prompt !== undefined) {

      await answer(prompt);

      return 0;

      return reloading ? RELOAD_EXIT_CODE : 0;

    }

    const reader = createInterface({ input: stdin, terminal: false });

    for await (const line of reader) {

      if (line.trim().length === 0) continue;

      await answer(line);

      if (reloading) break;

    }

    return 0;

    return reloading ? RELOAD_EXIT_CODE : 0;

  } finally {

    unsubscribe();

  }

/**

 * Restarting a session on the code as it is now.

 *

 * The interface is developed by running it, and every change meant leaving the

 * session, rebuilding, and starting again -- which loses the conversation that

 * prompted the change. `/reload` does the same three things without the reader

 * doing them, and only where they mean something: a session running from a

 * source checkout.

 *

 * A published install has no `src` to build from and no build script to run, so

 * `/reload` there would be a command that could only fail. It reports that

 * instead of trying.

 */

import { spawnSync } from "node:child_process";

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

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

import { fileURLToPath } from "node:url";

/** The exit code the interface uses to ask its runner for a restart. */

export const RELOAD_EXIT_CODE = 75;

/**

 * Whether this directory is something `/reload` could rebuild.

 *

 * Both have to be there. A published tarball ships `dist` and a manifest but no

 * `src`, and a manifest with no build script is nothing to rebuild with.

 */

export function isSourceCheckout(root: string): boolean {

  if (!existsSync(join(root, "src"))) return false;

  try {

    const manifest = JSON.parse(readFileSync(join(root, "package.json"), "utf8")) as {

      scripts?: Record<string, unknown>;

    };

    return typeof manifest.scripts?.["build"] === "string";

  } catch {

    return false;

  }

}

/** The package this process is running out of, when it is a source checkout. */

export function sourceCheckout(): string | undefined {

  const root = join(dirname(fileURLToPath(import.meta.url)), "..");

  return isSourceCheckout(root) ? root : undefined;

}

export interface RebuildResult {

  readonly ok: boolean;

  /** What the compiler said, when it failed. */

  readonly output: string;

}

/**

 * Rebuild the checkout.

 *

 * The compiler's own output is carried back rather than a summary of it: a

 * reload that fails is a compile error the reader has to read, and "build

 * failed" tells them nothing they can act on.

 */

export function rebuild(root: string): RebuildResult {

  const result = spawnSync("pnpm", ["run", "build"], { cwd: root, encoding: "utf8" });

  const output = `${result.stdout ?? ""}${result.stderr ?? ""}`.trim();

  return { ok: result.status === 0, output };

}

import { fleetPhrase, fleetRows } from "./coder-fleet.js";

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

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

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

import type { SkillSelection } from "./coder-skills.js";

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

      // 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

      // the ticker above keeps the fleet rows moving.

      // `/reload` restarts this session on the code as it is now. The rebuild

      // and the restart belong to the runner, which has the screen back by

      // then; the interface only asks, by exiting with a code of its own.

      if (/^\/reload\s*$/.test(prompt.trim())) {

        const root = sourceCheckout();

        if (root === undefined) {

          session.notice(

            "This session is not running from a source checkout, so there is nothing to " +

              "rebuild. `/reload` works where `openagents coder` was started from the repository.",

          );

          render();

          return;

        }

        // The transcript ends here. It is not written out on the way past:

        // reloading is something a reader does many times in a sitting, and a

        // command that quietly leaves a file behind each time is one they have

        // to clean up after. `/export` keeps a conversation when it is wanted.

        finish(RELOAD_EXIT_CODE);

        return;

      }

      // `/skills` opens a screen rather than sending a turn: it changes what

      // the next turn carries, so it is not something to say to the model.

      if (/^\/skills\s*$/.test(prompt.trim())) {

      "openagents coder — development build. Type a message and press enter. " +

        "Ctrl+D quits, Esc interrupts a reply. `/system` shows what the model is told, " +

        "`/skills` chooses which skills it is offered, `/export` writes the conversation " +

        "as ATIF.",

        "as ATIF, `/reload` restarts on the current source.",

    );

    render();

  });

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

import { tmpdir } from "node:os";

import { join } from "node:path";

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

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

const directory = (manifest?: Record<string, unknown>, withSource = true): string => {

  const root = mkdtempSync(join(tmpdir(), "coder-reload-"));

  if (withSource) mkdirSync(join(root, "src"));

  if (manifest !== undefined) {

    writeFileSync(join(root, "package.json"), JSON.stringify(manifest));

  }

  return root;

};

describe("deciding whether a session can reload itself", () => {

  it("recognizes a checkout with sources and a build script", () => {

    expect(isSourceCheckout(directory({ scripts: { build: "tsc" } }))).toBe(true);

  });

  it("refuses a published install, which ships no sources", () => {

    // `/reload` there could only fail, so it reports instead of trying.

    expect(isSourceCheckout(directory({ scripts: { build: "tsc" } }, false))).toBe(false);

  });

  it("refuses a checkout with nothing to build with", () => {

    expect(isSourceCheckout(directory({ scripts: {} }))).toBe(false);

    expect(isSourceCheckout(directory({}))).toBe(false);

  });

  it("refuses a directory with no manifest, or an unreadable one", () => {

    expect(isSourceCheckout(directory())).toBe(false);

    const broken = directory();

    writeFileSync(join(broken, "package.json"), "{not json");

    expect(isSourceCheckout(broken)).toBe(false);

  });

  it("recognizes the checkout these tests run from", () => {

    // The case the command exists for.

    expect(sourceCheckout()).toBeDefined();

  });

  it("asks for a restart with a code no ordinary exit uses", () => {

    expect(RELOAD_EXIT_CODE).not.toBe(0);

    expect(RELOAD_EXIT_CODE).not.toBe(1);

    expect(RELOAD_EXIT_CODE).not.toBe(130);

  });

});

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

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

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

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

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

/** A writable that records what the interface painted. */

    await running;

  });

});

describe("the /reload command", () => {

  it("asks the runner to restart, and sends nothing to the model", async () => {

    const stdin = new FakeIn();

    const stdout = new FakeOut();

    const prompts: string[] = [];

    const session = new CoderSession(

      {

        model: "scripted",

        // eslint-disable-next-line require-yield -- a turn that must not happen

        async *reply(prompt: string) {

          prompts.push(prompt);

        },

      },

      "repo",

      "main",

    );

    const running = runCoderUi(session, {

      stdin: stdin as unknown as NodeJS.ReadStream,

      stdout: stdout as unknown as NodeJS.WriteStream,

    });

    stdin.emit("data", "/reload");

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

    // These tests run from a source checkout, so the command applies: the

    // interface exits with the code its runner rebuilds on.

    await expect(running).resolves.toBe(RELOAD_EXIT_CODE);

    expect(prompts).toEqual([]);

    expect(session.snapshot().turns).toBe(0);

  });

});