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

    "filesScanned": 2473,

    "candidateCount": 16,

    "byMode": {

      "false_green_coverage_theater": 15,

{

  "schemaVersion": "1",

  "repository": "OpenAgentsInc/openagents",

  "sourceDigest": "sha256:f9692575e1acde3a37330314bde3362b9552f997096a73f4d036c22470650d52",

  "sourceDigest": "sha256:d9d93b65d7614d382ef47b625cf1b305e5f4a907d8103d09dd0951d49b3d9ff0",

  "surfaces": [

    {

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

      "oracles": [

        {

          "type": "test",

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

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

        },

        {

          "type": "behavior-contract",

    }),

).pipe(Command.withDescription("List the topics in one forum board"));

const forumQueryArgument = Argument.string("query").pipe(

  Argument.withDescription("Words to match in topic titles, post bodies, and authors"),

);

const forumSearchCommand = Command.make(

  "search",

  { query: forumQueryArgument, board: forumBoardFlag, page: forumPageFlag },

  ({ query, board, page }) =>

    Effect.gen(function* () {

      if (query.trim() === "") {

        return yield* new InputError({ message: "Pass the words to search for." });

      }

      const flags = yield* rootCommand;

      const session = yield* resolveApiSession(endpointOverrides(flags));

      const forums = yield* ForumClient;

      const output = yield* Output;

      const pageNum = parsePage(page);

      const value = yield* forums.search({

        origin: session.endpoint.origin,

        token: session.token,

        query,

        ...(Option.isNone(board) ? {} : { board: board.value }),

        ...(pageNum === undefined ? {} : { page: pageNum }),

      });

      const topics = rows(value, "topics");

      const human =

        topics.length === 0

          ? ["No topics match."]

          : topics.map((topic) => {

              const author = record(topic["author"]);

              const home = record(topic["board"]);

              const who =

                author["display_name"] === undefined ? "?" : String(author["display_name"]);

              const where = home["slug"] === undefined ? "" : ` [${String(home["slug"])}]`;

              return `${String(topic["id"]).slice(0, 8)} — ${String(topic["title"])} — ${who}${where}`;

            });

      yield* output.write({ value, human }, outputMode(flags.json));

    }),

).pipe(Command.withDescription("Search forum topics by title, visible post body, or author"));

const topicIdArgument = Argument.string("id").pipe(

  Argument.withDescription("Topic id (the prefix of a topic URL works too)"),

);

  Command.withSubcommands([

    forumBoardsCommand,

    forumTopicsCommand,

    forumSearchCommand,

    forumTopicCommand,

    forumPostCommand,

    forumReplyCommand,

  readonly topics: (

    input: AuthenticatedApi & { readonly board: string; readonly page?: number },

  ) => Effect.Effect<unknown, CliError>;

  readonly search: (

    input: AuthenticatedApi & {

      readonly query: string;

      readonly board?: string;

      readonly page?: number;

    },

  ) => Effect.Effect<unknown, CliError>;

  readonly topic: (

    input: AuthenticatedApi & { readonly id: string; readonly page?: number },

  ) => Effect.Effect<unknown, CliError>;

          }`,

        }),

      search: (input) =>

        request("search forum topics", {

          ...input,

          method: "GET",

          path: `${API_VERSION_PATH}/forum/topics?q=${encodeURIComponent(input.query)}${

            input.board === undefined ? "" : `&forum=${encodeURIComponent(input.board)}`

          }${input.page === undefined ? "" : `&page=${input.page}`}`,

        }),

      topic: (input) =>

        request("read a forum topic", {

          ...input,

import * as NodeServices from "@effect/platform-node/NodeServices";

import { Effect, Layer } from "effect";

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

import { apiTransportTestLayer, type ApiRequest, type ApiResponse } from "../src/api-transport.js";

import { runCliWith } from "../src/cli.js";

import { credentialStoreUnavailableLayer } from "../src/credential-store.js";

import { environmentLayerFromValues } from "../src/environment.js";

import { forumClientLayer } from "../src/forum-client.js";

import { gitRunnerTestLayer } from "../src/git-runner.js";

import { outputTestLayer, type OutputDocument, type OutputMode } from "../src/output.js";

import { persistedConfigurationTestLayer } from "../src/persisted-configuration.js";

import { requestBodyInputTestLayer } from "../src/request-body-input.js";

import { secretInputTestLayer } from "../src/secret-input.js";

import { terminalSessionTestLayer } from "../src/terminal-session.js";

const harness = (response: ApiResponse) => {

  const requests: Array<ApiRequest> = [];

  const output: Array<{ readonly document: OutputDocument; readonly mode: OutputMode }> = [];

  const transport = apiTransportTestLayer((input) =>

    Effect.sync(() => {

      requests.push(input);

      return response;

    }),

  );

  const layer = Layer.mergeAll(

    NodeServices.layer,

    environmentLayerFromValues({ token: "oa_pat_fixture" }),

    persistedConfigurationTestLayer({}),

    terminalSessionTestLayer(false),

    credentialStoreUnavailableLayer,

    gitRunnerTestLayer(() => Effect.void),

    secretInputTestLayer("stdin-token"),

    requestBodyInputTestLayer({}),

    transport,

    forumClientLayer.pipe(Layer.provide(transport)),

    outputTestLayer((document, mode) =>

      Effect.sync(() => {

        output.push({ document, mode });

      }),

    ),

  );

  return { layer, requests, output };

};

const topics = {

  query: "fable",

  topics: [

    {

      id: "415e16a7-183c-40d7-90c6-1c0e81a4f873",

      title: "Independent audit",

      author: { display_name: "Fable Coder", is_agent: true },

      board: { slug: "product-promises", title: "Product Promises" },

    },

  ],

};

describe("openagents forum search", () => {

  it("sends q, board, and page to the topics route", async () => {

    const harnessed = harness({ status: 200, body: topics });

    await Effect.runPromise(

      runCliWith([

        "--profile",

        "local",

        "forum",

        "search",

        "fable",

        "--board",

        "general",

        "--page",

        "2",

      ]).pipe(Effect.provide(harnessed.layer)),

    );

    expect(harnessed.requests).toHaveLength(1);

    expect(harnessed.requests[0]?.method).toBe("GET");

    expect(harnessed.requests[0]?.path).toBe("/api/v1/forum/topics?q=fable&forum=general&page=2");

  });

  it("renders each match with its author and board", async () => {

    const harnessed = harness({ status: 200, body: topics });

    await Effect.runPromise(

      runCliWith(["--profile", "local", "forum", "search", "fable"]).pipe(

        Effect.provide(harnessed.layer),

      ),

    );

    expect(harnessed.requests[0]?.path).toBe("/api/v1/forum/topics?q=fable");

    expect(harnessed.output[0]?.document.human).toEqual([

      "415e16a7 — Independent audit — Fable Coder [product-promises]",

    ]);

  });

  it("says so when nothing matches", async () => {

    const harnessed = harness({ status: 200, body: { query: "nothing", topics: [] } });

    await Effect.runPromise(

      runCliWith(["--profile", "local", "forum", "search", "nothing"]).pipe(

        Effect.provide(harnessed.layer),

      ),

    );

    expect(harnessed.output[0]?.document.human).toEqual(["No topics match."]);

  });

});