@bastani/atomic 0.6.8-0 → 0.7.0-1

package/src/sdk/workflows/builtin/ralph/claude/index.ts

@@ -1,272 +0,0 @@
-/**
- * Ralph workflow for Claude Code — plan → orchestrate → review loop.
- *
- * Each sub-agent invocation spawns its own visible session in the graph,
- * so users can see each iteration's progress in real time. The loop
- * terminates when:
- *   - `max_loops` iterations have completed (defaults to {@link DEFAULT_MAX_LOOPS}), OR
- *   - Both parallel reviewer passes return `overall_correctness === "patch is correct"`.
- *
- * On a failed review the merged findings are formatted into a markdown
- * brief by {@link formatReviewForReplan} and fed into the next iteration's
- * planner, which is responsible for validating, deduping, and clustering
- * them into shared root causes before revising the RFC.
- *
- * The reviewer stages run **headless** via the Claude Agent SDK with
- * `outputFormat: { type: "json_schema", schema: REVIEW_RESULT_JSON_SCHEMA }`,
- * so the SDK validates {@link ReviewResultSchema} before returning. The
- * validated object is read from `s.session.lastStructuredOutput` — no text
- * parsing required. Running the reviewers headless (no tmux pane) keeps the
- * graph focused on stages the user cares about and lets the SDK enforce the
- * schema without TUI round-trips.
- *
- * Run: atomic workflow -n ralph -a claude "<your spec>"
- */
-
-import { defineWorkflow, extractAssistantText } from "../../../index.ts";
-
-import {
-  buildPlannerPrompt,
-  buildOrchestratorPrompt,
-  buildCodeSimplifierPrompt,
-  buildInfraDiscoveryPrompts,
-  buildReviewPrompt,
-  filterActionable,
-  formatReviewForReplan,
-  mergeReviewResults,
-  REVIEW_RESULT_JSON_SCHEMA,
-  type ReviewResult,
-  type StructuredReviewResult,
-} from "../helpers/prompts.ts";
-import { hasActionableFindings } from "../helpers/review.ts";
-import { captureBranchChangeset } from "../helpers/git.ts";
-
-const DEFAULT_MAX_LOOPS = 10;
-
-// The orchestrator stage implements the actual code changes and can run for
-// a very long time on large tasks. Completion is detected via session file
-// watching for idle and result events from Claude's own SDK — no manual
-// timeout is needed.
-
-/**
- * Turn the SDK's validated structured_output (plus raw transcript text) into a
- * {@link StructuredReviewResult}. When the SDK failed to validate the schema
- * (`error_max_structured_output_retries`) `structured_output` is absent and
- * we propagate `null` so {@link mergeReviewResults} treats the pass as
- * unknown/actionable.
- */
-function extractReview(
-  structuredOutput: unknown,
-  rawText: string,
-): StructuredReviewResult {
-  if (structuredOutput && typeof structuredOutput === "object") {
-    return {
-      structured: filterActionable(structuredOutput as ReviewResult),
-      raw: rawText,
-    };
-  }
-  return { structured: null, raw: rawText };
-}
-
-export default defineWorkflow({
-  name: "ralph",
-  source: import.meta.path,
-  description: "Plan → orchestrate → review loop with bounded iteration",
-  inputs: [
-    {
-      name: "prompt",
-      type: "text",
-      required: true,
-      description: "task prompt",
-    },
-    {
-      name: "max_loops",
-      type: "integer",
-      description: "maximum number of plan/orchestrate/review iterations",
-      default: DEFAULT_MAX_LOOPS,
-    },
-  ],
-})
-  .for("claude")
-  .run(async (ctx) => {
-    const prompt = ctx.inputs.prompt ?? "";
-    const maxLoops = ctx.inputs.max_loops ?? DEFAULT_MAX_LOOPS;
-    let reviewReport = "";
-
-    for (let iteration = 1; iteration <= maxLoops; iteration++) {
-      // ── Plan ────────────────────────────────────────────────────────────
-      const planner = await ctx.stage(
-        { name: `planner-${iteration}` },
-        {
-          chatFlags: [
-            "--agent",
-            "planner",
-            "--allow-dangerously-skip-permissions",
-            "--dangerously-skip-permissions",
-          ],
-        },
-        {},
-        async (s) => {
-          const result = await s.session.query(
-            buildPlannerPrompt(prompt, {
-              iteration,
-              reviewReport: reviewReport || undefined,
-            }),
-          );
-          s.save(s.sessionId);
-          return extractAssistantText(result, 0);
-        },
-      );
-
-      // ── Orchestrate ─────────────────────────────────────────────────────
-      await ctx.stage(
-        { name: `orchestrator-${iteration}` },
-        {
-          chatFlags: [
-            "--agent",
-            "orchestrator",
-            "--allow-dangerously-skip-permissions",
-            "--dangerously-skip-permissions",
-          ],
-        },
-        {},
-        async (s) => {
-          await s.session.query(
-            buildOrchestratorPrompt(prompt, {
-              plannerNotes: planner.result,
-            }),
-          );
-          s.save(s.sessionId);
-        },
-      );
-
-      // ── Code Simplifier ─────────────────────────────────────────────────
-      await ctx.stage(
-        { name: `code-simplifier-${iteration}` },
-        {
-          chatFlags: [
-            "--agent",
-            "code-simplifier",
-            "--allow-dangerously-skip-permissions",
-            "--dangerously-skip-permissions",
-          ],
-        },
-        {},
-        async (s) => {
-          await s.session.query(
-            buildCodeSimplifierPrompt(prompt, {
-              plannerNotes: planner.result,
-            }),
-          );
-          s.save(s.sessionId);
-        },
-      );
-
-      // ── Infrastructure Discovery (three parallel sub-agent stages) ────
-      const changeset = await captureBranchChangeset();
-      const discoveryPrompts = buildInfraDiscoveryPrompts();
-
-      const [locatorResult, analyzerResult, patternResult] = await Promise.all([
-        ctx.stage(
-          { name: `infra-locate-${iteration}`, headless: true },
-          {},
-          {},
-          async (s) => {
-            const result = await s.session.query(discoveryPrompts.locator, {
-              agent: "codebase-locator",
-              permissionMode: "bypassPermissions",
-              allowDangerouslySkipPermissions: true,
-            });
-            s.save(s.sessionId);
-            return extractAssistantText(result, 0);
-          },
-        ),
-        ctx.stage(
-          { name: `infra-analyze-${iteration}`, headless: true },
-          {},
-          {},
-          async (s) => {
-            const result = await s.session.query(discoveryPrompts.analyzer, {
-              agent: "codebase-analyzer",
-              permissionMode: "bypassPermissions",
-              allowDangerouslySkipPermissions: true,
-            });
-            s.save(s.sessionId);
-            return extractAssistantText(result, 0);
-          },
-        ),
-        ctx.stage(
-          { name: `infra-patterns-${iteration}`, headless: true },
-          {},
-          {},
-          async (s) => {
-            const result = await s.session.query(
-              discoveryPrompts.patternFinder,
-              {
-                agent: "codebase-pattern-finder",
-                permissionMode: "bypassPermissions",
-                allowDangerouslySkipPermissions: true,
-              },
-            );
-            s.save(s.sessionId);
-            return extractAssistantText(result, 0);
-          },
-        ),
-      ]);
-
-      const discoveryContext = [
-        "### Infrastructure Files (codebase-locator)\n\n" +
-          locatorResult.result,
-        "### Infrastructure Analysis (codebase-analyzer)\n\n" +
-          analyzerResult.result,
-        "### Build & Test Patterns (codebase-pattern-finder)\n\n" +
-          patternResult.result,
-      ].join("\n\n---\n\n");
-
-      // ── Review (two parallel headless passes with schema enforcement) ──
-      const reviewPrompt = buildReviewPrompt(prompt, {
-        changeset,
-        iteration,
-        discoveryContext,
-      });
-
-      const runReviewer = (name: string) =>
-        ctx.stage(
-          { name, headless: true },
-          {},
-          {},
-          async (s) => {
-            const result = await s.session.query(reviewPrompt, {
-              agent: "reviewer",
-              permissionMode: "bypassPermissions",
-              allowDangerouslySkipPermissions: true,
-              outputFormat: {
-                type: "json_schema",
-                schema: REVIEW_RESULT_JSON_SCHEMA,
-              },
-            });
-            s.save(s.sessionId);
-            return extractReview(
-              s.session.lastStructuredOutput,
-              extractAssistantText(result, 0),
-            );
-          },
-        );
-
-      const [reviewA, reviewB] = await Promise.all([
-        runReviewer(`reviewer-${iteration}-a`),
-        runReviewer(`reviewer-${iteration}-b`),
-      ]);
-
-      const merged = mergeReviewResults(reviewA.result, reviewB.result);
-      const parsed = merged.structured;
-      const reviewRaw = merged.raw;
-
-      // Both reviewers agree the code is clean → done
-      if (!hasActionableFindings(parsed, reviewRaw)) break;
-
-      // Findings exist — format them for the next iteration's planner.
-      reviewReport = formatReviewForReplan(parsed, reviewRaw);
-    }
-  })
-  .compile();

package/src/sdk/workflows/builtin/ralph/copilot/index.ts

@@ -1,298 +0,0 @@
-/**
- * Ralph workflow for Copilot — plan → orchestrate → review loop.
- *
- * Each sub-agent invocation spawns its own visible session in the graph,
- * so users can see each iteration's progress in real time. The loop
- * terminates when:
- *   - `max_loops` iterations have completed (defaults to {@link DEFAULT_MAX_LOOPS}), OR
- *   - Both parallel reviewer passes return `overall_correctness === "patch is correct"`.
- *
- * On a failed review the merged findings are formatted into a markdown
- * brief by {@link formatReviewForReplan} and fed into the next iteration's
- * planner, which is responsible for validating, deduping, and clustering
- * them into shared root causes before revising the RFC.
- *
- * The reviewer stages use a `submit_review` custom tool (defined via
- * `defineTool` with Zod schema validation) to guarantee the review result
- * matches the {@link ReviewResultSchema}. The Copilot SDK validates tool
- * call arguments against the Zod schema before the handler fires.
- *
- * Run: atomic workflow -n ralph -a copilot "<your spec>"
- */
-
-import { defineWorkflow } from "../../../index.ts";
-import { defineTool } from "@github/copilot-sdk";
-import type { SessionEvent } from "@github/copilot-sdk";
-
-import {
-  buildPlannerPrompt,
-  buildOrchestratorPrompt,
-  buildCodeSimplifierPrompt,
-  buildInfraDiscoveryPrompts,
-  buildReviewPrompt,
-  filterActionable,
-  formatReviewForReplan,
-  mergeReviewResults,
-  ReviewResultSchema,
-  type ReviewResult,
-  type StructuredReviewResult,
-} from "../helpers/prompts.ts";
-import { hasActionableFindings } from "../helpers/review.ts";
-import { captureBranchChangeset } from "../helpers/git.ts";
-import { buildRalphReviewerAgent } from "../helpers/copilot-reviewer.ts";
-
-const SUBMIT_REVIEW_TOOL_NAME = "submit_review";
-
-const DEFAULT_MAX_LOOPS = 10;
-
-const SUBMIT_REVIEW_DESCRIPTION =
-  "Submit the structured code review result. You MUST call this tool " +
-  "exactly once with your complete review. Do not output the review as " +
-  "plain text — use this tool.";
-
-/**
- * Concatenate the text content of every top-level assistant message in the
- * event stream.
- *
- * Why not just `.at(-1)`? Two traps:
- *
- * 1. A single Copilot turn is one `assistant.message` event that carries BOTH
- *    prose AND a `toolRequests[]` array. When the model ends a turn with
- *    tool-calls-only (e.g. the planner's final `TaskList` verification call),
- *    `content` is an empty string — picking the final message drops the
- *    planner's actual reasoning from the earlier turns.
- * 2. `assistant.message` events have a `parentToolCallId` field populated when
- *    they originate from a sub-agent spawned by the parent. `getMessages()`
- *    returns the complete history including those, so `.at(-1)` can land on a
- *    sub-agent's final message instead of the top-level agent's. Filter them
- *    out to get only the agent's own turns.
- *
- * Joining every non-empty top-level content string preserves the full
- * commentary across all turns, which is what downstream stages (e.g. the
- * orchestrator reading the planner's handoff) actually need.
- */
-function getAssistantText(messages: SessionEvent[]): string {
-  return messages
-    .filter(
-      (m): m is Extract<SessionEvent, { type: "assistant.message" }> =>
-        m.type === "assistant.message" && !m.data.parentToolCallId,
-    )
-    .map((m) => m.data.content)
-    .filter((c) => c.length > 0)
-    .join("\n\n");
-}
-
-export default defineWorkflow({
-  name: "ralph",
-  source: import.meta.path,
-  description: "Plan → orchestrate → review loop with bounded iteration",
-  inputs: [
-    {
-      name: "prompt",
-      type: "text",
-      required: true,
-      description: "task prompt",
-    },
-    {
-      name: "max_loops",
-      type: "integer",
-      description: "maximum number of plan/orchestrate/review iterations",
-      default: DEFAULT_MAX_LOOPS,
-    },
-  ],
-})
-  .for("copilot")
-  .run(async (ctx) => {
-    const userPromptText = ctx.inputs.prompt ?? "";
-    const maxLoops = ctx.inputs.max_loops ?? DEFAULT_MAX_LOOPS;
-    let reviewReport = "";
-
-    for (let iteration = 1; iteration <= maxLoops; iteration++) {
-      // ── Plan ──────────────────────────────────────────────────────────
-      const planner = await ctx.stage(
-        { name: `planner-${iteration}` },
-        {},
-        { agent: "planner" },
-        async (s) => {
-          await s.session.send({
-            prompt: buildPlannerPrompt(userPromptText, {
-              iteration,
-              reviewReport: reviewReport || undefined,
-            }),
-          });
-          const messages = await s.session.getMessages();
-          s.save(messages);
-          return getAssistantText(messages);
-        },
-      );
-
-      // ── Orchestrate ───────────────────────────────────────────────────
-      await ctx.stage(
-        { name: `orchestrator-${iteration}` },
-        {},
-        { agent: "orchestrator" },
-        async (s) => {
-          await s.session.send({
-            prompt: buildOrchestratorPrompt(userPromptText, {
-              plannerNotes: planner.result,
-            }),
-          });
-          s.save(await s.session.getMessages());
-        },
-      );
-
-      // ── Code Simplifier ───────────────────────────────────────────────
-      await ctx.stage(
-        { name: `code-simplifier-${iteration}` },
-        {},
-        { agent: "code-simplifier" },
-        async (s) => {
-          await s.session.send({
-            prompt: buildCodeSimplifierPrompt(userPromptText, {
-              plannerNotes: planner.result,
-            }),
-          });
-          s.save(await s.session.getMessages());
-        },
-      );
-
-      // ── Infrastructure Discovery (three parallel sub-agent stages) ──
-      const changeset = await captureBranchChangeset();
-      const discoveryPrompts = buildInfraDiscoveryPrompts();
-
-      const [locatorResult, analyzerResult, patternResult] = await Promise.all([
-        ctx.stage(
-          { name: `infra-locate-${iteration}`, headless: true },
-          {},
-          { agent: "codebase-locator" },
-          async (s) => {
-            await s.session.send({ prompt: discoveryPrompts.locator });
-            const messages = await s.session.getMessages();
-            s.save(messages);
-            return getAssistantText(messages);
-          },
-        ),
-        ctx.stage(
-          { name: `infra-analyze-${iteration}`, headless: true },
-          {},
-          { agent: "codebase-analyzer" },
-          async (s) => {
-            await s.session.send({ prompt: discoveryPrompts.analyzer });
-            const messages = await s.session.getMessages();
-            s.save(messages);
-            return getAssistantText(messages);
-          },
-        ),
-        ctx.stage(
-          { name: `infra-patterns-${iteration}`, headless: true },
-          {},
-          { agent: "codebase-pattern-finder" },
-          async (s) => {
-            await s.session.send({ prompt: discoveryPrompts.patternFinder });
-            const messages = await s.session.getMessages();
-            s.save(messages);
-            return getAssistantText(messages);
-          },
-        ),
-      ]);
-
-      const discoveryContext = [
-        "### Infrastructure Files (codebase-locator)\n\n" +
-          locatorResult.result,
-        "### Infrastructure Analysis (codebase-analyzer)\n\n" +
-          analyzerResult.result,
-        "### Build & Test Patterns (codebase-pattern-finder)\n\n" +
-          patternResult.result,
-      ].join("\n\n---\n\n");
-
-      // ── Review (two parallel passes) ──────────────────────────────────
-      const reviewPrompt = buildReviewPrompt(userPromptText, {
-        changeset,
-        iteration,
-        useSubmitTool: true,
-        discoveryContext,
-      });
-
-      // Each parallel reviewer gets its own tool + capture ref so they
-      // don't race on a shared mutable.
-      let captureA: ReviewResult | null = null;
-      let captureB: ReviewResult | null = null;
-
-      const toolA = defineTool(SUBMIT_REVIEW_TOOL_NAME, {
-        description: SUBMIT_REVIEW_DESCRIPTION,
-        parameters: ReviewResultSchema,
-        skipPermission: true,
-        handler: async (data: ReviewResult) => {
-          captureA = filterActionable(data);
-          return "Review submitted successfully.";
-        },
-      });
-
-      const toolB = defineTool(SUBMIT_REVIEW_TOOL_NAME, {
-        description: SUBMIT_REVIEW_DESCRIPTION,
-        parameters: ReviewResultSchema,
-        skipPermission: true,
-        handler: async (data: ReviewResult) => {
-          captureB = filterActionable(data);
-          return "Review submitted successfully.";
-        },
-      });
-
-      // Inline reviewer agent config overrides the disk-based
-      // `.github/agents/reviewer.md`. Defining it here lets the tool
-      // allowlist include `submit_review` — disk-loaded agents filter the
-      // frontmatter `tools:` list against Copilot's built-in alias
-      // registry at parse time, so session-level custom tools are dropped.
-      const ralphReviewer = buildRalphReviewerAgent(SUBMIT_REVIEW_TOOL_NAME);
-
-      const [reviewA, reviewB] = await Promise.all([
-        ctx.stage(
-          { name: `reviewer-${iteration}-a` },
-          {},
-          {
-            agent: "reviewer",
-            tools: [toolA],
-            customAgents: [ralphReviewer],
-          },
-          async (s) => {
-            await s.session.send({ prompt: reviewPrompt });
-            const messages = await s.session.getMessages();
-            s.save(messages);
-            return {
-              structured: captureA,
-              raw: getAssistantText(messages),
-            } as StructuredReviewResult;
-          },
-        ),
-        ctx.stage(
-          { name: `reviewer-${iteration}-b` },
-          {},
-          {
-            agent: "reviewer",
-            tools: [toolB],
-            customAgents: [ralphReviewer],
-          },
-          async (s) => {
-            await s.session.send({ prompt: reviewPrompt });
-            const messages = await s.session.getMessages();
-            s.save(messages);
-            return {
-              structured: captureB,
-              raw: getAssistantText(messages),
-            } as StructuredReviewResult;
-          },
-        ),
-      ]);
-
-      const merged = mergeReviewResults(reviewA.result, reviewB.result);
-      const parsed = merged.structured;
-      const reviewRaw = merged.raw;
-
-      // Both reviewers agree the code is clean → done
-      if (!hasActionableFindings(parsed, reviewRaw)) break;
-
-      // Findings exist — format them for the next iteration's planner.
-      reviewReport = formatReviewForReplan(parsed, reviewRaw);
-    }
-  })
-  .compile();

package/src/sdk/workflows/builtin/ralph/helpers/copilot-reviewer.ts

@@ -1,105 +0,0 @@
-/**
- * Inline reviewer `CustomAgentConfig` for the Copilot ralph workflow.
- *
- * Why this exists instead of reusing `.github/agents/reviewer.md`: Copilot
- * CLI parses the disk agent's `tools:` frontmatter against its built-in
- * alias registry at load time. Custom tool names (like `submit_review`
- * registered via `defineTool` at session creation) are unknown at that
- * moment and get silently dropped. Defining the agent inline in
- * `customAgents` runs the tool-allowlist check against the session's live
- * tool registry, so `submit_review` is actually exposed to the subagent.
- *
- * This is a ralph-specific fork — the disk reviewer stays general-purpose
- * for non-ralph invocations.
- */
-
-import type { CustomAgentConfig } from "@github/copilot-sdk";
-
-const REVIEWER_PROMPT = `# Review guidelines:
-
-You are acting as a reviewer for a proposed code change made by another engineer.
-
-Below are some default guidelines for determining whether the original author would appreciate the issue being flagged.
-
-These are not the final word in determining whether an issue is a bug. In many cases, you will encounter other, more specific guidelines. These may be present elsewhere in a developer message, a user message, a file, or even elsewhere in this system message.
-Those guidelines should be considered to override these general instructions.
-
-Here are the general guidelines for determining whether something is a bug and should be flagged.
-
-1. It meaningfully impacts the accuracy, performance, security, or maintainability of the code.
-2. The bug is discrete and actionable (i.e. not a general issue with the codebase or a combination of multiple issues).
-3. Fixing the bug does not demand a level of rigor that is not present in the rest of the codebase (e.g. one doesn't need very detailed comments and input validation in a repository of one-off scripts in personal projects)
-4. The bug was introduced in the commit (pre-existing bugs should not be flagged).
-5. The author of the original PR would likely fix the issue if they were made aware of it.
-6. The bug does not rely on unstated assumptions about the codebase or author's intent.
-7. It is not enough to speculate that a change may disrupt another part of the codebase, to be considered a bug, one must identify the other parts of the code that are provably affected.
-8. The bug is clearly not just an intentional change by the original author.
-9. Use the repository's \`AGENTS.md\` and/or \`CLAUDE.md\` files (if present) for guidance on style, conventions, testing expectations, and architectural patterns. Your review should respect these project-level norms — flag deviations only when they conflict with correctness or security, not personal preference.
-
-When flagging a bug, you will also provide an accompanying comment. Once again, these guidelines are not the final word on how to construct a comment -- defer to any subsequent guidelines that you encounter.
-
-1. The comment should be clear about why the issue is a bug.
-2. The comment should appropriately communicate the severity of the issue. It should not claim that an issue is more severe than it actually is.
-3. The comment should be brief. The body should be at most 1 paragraph. It should not introduce line breaks within the natural language flow unless it is necessary for the code fragment.
-4. The comment should not include any chunks of code longer than 3 lines. Any code chunks should be wrapped in markdown inline code tags or a code block.
-5. The comment should clearly and explicitly communicate the scenarios, environments, or inputs that are necessary for the bug to arise. The comment should immediately indicate that the issue's severity depends on these factors.
-6. The comment's tone should be matter-of-fact and not accusatory or overly positive. It should read as a helpful AI assistant suggestion without sounding too much like a human reviewer.
-7. The comment should be written such that the original author can immediately grasp the idea without close reading.
-8. The comment should avoid excessive flattery and comments that are not helpful to the original author. The comment should avoid phrasing like "Great job ...", "Thanks for ...".
-
-Below are some more detailed guidelines that you should apply to this specific review.
-
-HOW MANY FINDINGS TO RETURN:
-
-Output all findings that the original author would fix if they knew about it. If there is no finding that a person would definitely love to see and fix, prefer outputting no findings. Do not stop at the first qualifying finding. Continue until you've listed every qualifying finding.
-
-GUIDELINES:
-
-- Ignore trivial style unless it obscures meaning or violates documented standards.
-- Use one comment per distinct issue (or a multi-line range if necessary).
-- Use \`\`\`suggestion blocks ONLY for concrete replacement code (minimal lines; no commentary inside the block).
-- In every \`\`\`suggestion block, preserve the exact leading whitespace of the replaced lines (spaces vs tabs, number of spaces).
-- Do NOT introduce or remove outer indentation levels unless that is the actual fix.
-
-The comments will be presented in the code review as inline comments. You should avoid providing unnecessary location details in the comment body. Always keep the line range as short as possible for interpreting the issue. Avoid ranges longer than 5–10 lines; instead, choose the most suitable subrange that pinpoints the problem.
-
-At the beginning of the finding title, tag the bug with priority level. For example "[P1] Un-padding slices along wrong tensor dimensions". [P0] – Drop everything to fix. Blocking release, operations, or major usage. Only use for universal issues that do not depend on any assumptions about the inputs. · [P1] – Urgent. Should be addressed in the next cycle · [P2] – Normal. To be fixed eventually · [P3] – Low. Nice to have.
-
-Additionally, include a numeric priority field in the JSON output for each finding: set "priority" to 0 for P0, 1 for P1, 2 for P2, or 3 for P3. If a priority cannot be determined, omit the field or use null.
-
-At the end of your findings, output an "overall correctness" verdict of whether or not the patch should be considered "correct".
-Correct implies that existing code and tests will not break, and the patch is free of bugs and other blocking issues.
-Ignore non-blocking issues such as style, formatting, typos, documentation, and other nits.
-
-FORMATTING GUIDELINES:
-The finding description should be one paragraph.
-
-OUTPUT: You MUST submit your review by calling the \`submit_review\` tool exactly once with the complete structured review. Do NOT output the review as plain text — the tool enforces the required schema.`;
-
-/**
- * Build the ralph-specific reviewer `CustomAgentConfig`.
- *
- * Pass the session-level custom tool name(s) (e.g. `"submit_review"`) via
- * `submitReviewToolName` so the reviewer subagent's tool allowlist
- * includes it. Session-level tools named here are visible to the subagent;
- * omitted names are filtered out.
- */
-export function buildRalphReviewerAgent(
-  submitReviewToolName: string,
-): CustomAgentConfig {
-  return {
-    name: "reviewer",
-    displayName: "reviewer",
-    description: "Code reviewer for proposed code changes.",
-    tools: [
-      "execute",
-      "agent",
-      "search",
-      "read",
-      "web_fetch",
-      "sql",
-      submitReviewToolName,
-    ],
-    prompt: REVIEWER_PROMPT,
-  };
-}