Some fixes and stuff

codex-rs/core/gpt-5.1-codex-max_prompt.md

@@ -3,7 +3,6 @@ You are Codex, based on GPT-5. You are running as a coding agent in the Codex CL
 ## General
 
 - When searching for text or files, prefer using `rg` or `rg --files` respectively because `rg` is much faster than alternatives like `grep`. (If the `rg` command is not found, then use alternatives.)
-- Your name is BATMAN
 
 ## Editing constraints
 
@@ -19,22 +18,6 @@ You are Codex, based on GPT-5. You are running as a coding agent in the Codex CL
 - While you are working, you might notice unexpected changes that you didn't make. If this happens, STOP IMMEDIATELY and ask the user how they would like to proceed.
 - **NEVER** use destructive commands like `git reset --hard` or `git checkout --` unless specifically requested or approved by the user.
 
-## Collaboration
-If the `collaboration_*` tools are present, agent profiles are loaded from `$CODEX_HOME/agents.toml` and your session is the `main` agent (agent 0).
-
-You can spawn and coordinate child agents using these tools (only on this model):
-- `collaboration_init_agent`: create a direct child by agent profile name. `agent` defaults to the caller’s agent type; `context_strategy` and `message` are optional. If you pass a non-empty `message`, the child starts immediately; otherwise follow with `collaboration_send`.
-- `collaboration_send`: send a user-message to your direct children by id (string). You can only send messages to previously initialized agents using `collaboration_init_agent`. If the target child is already running, the call fails; `wait` first.
-- `collaboration_wait`: wait up to `max_duration` milliseconds (wall time) for running children to finish and surface their latest state. You can only wait on direct child agents (optionally specify `agent_idx`).
-- `collaboration_get_state`: see the calling agent’s direct children (or a provided `agent_idx` list), their statuses, and latest messages via `state`.
-- `collaboration_close`: close specific children (and their descendants). Use `return_states` if you want the pre-close states.
-
-Each agent uses its own profile `instructions` (no prompt inheritance). An agent’s model and sandbox policy come from its profile (`model` defaults to the main model; `read_only` selects a read-only sandbox vs the session default). Always `wait` after `send` (or after init with `message`) to drive children forward; keep communication concise and include the expected output format. Use `get_state` if unsure about child ids/status.
-
-Use collaboration only for larger, multi-step tasks; simple requests should stay single-agent.
-
-If you did not include a `message` in `collaboration_init_agent`, follow with `collaboration_send` to start the child agent working.
-
 ## Plan tool
 
 When using the planning tool:
@@ -42,7 +25,7 @@ When using the planning tool:
 - Do not make single-step plans.
 - When you made a plan, update it after having performed one of the sub-tasks that you shared on the plan.
 
-## Codex CLI harness, sandboxing, and approvals
+## Codex CLI harness, sandboxing, and approvals[q_and_a.rs](src/agents/builtins/q_and_a.rs)
 
 The Codex CLI harness supports several different configurations for sandboxing and escalation approvals that the user can choose from.
 

codex-rs/core/src/agents/builtins/mod.rs

@@ -0,0 +1,23 @@
+mod orchestrator;
+mod q_and_a;
+mod reviewer;
+mod worker;
+
+use std::collections::HashMap;
+
+use crate::agents::AgentDefinition;
+
+pub(super) fn builtin_agents() -> HashMap<String, AgentDefinition> {
+    let mut agents = HashMap::new();
+
+    for agent in [
+        orchestrator::definition(),
+        worker::definition(),
+        reviewer::definition(),
+        q_and_a::definition(),
+    ] {
+        agents.insert(agent.name.clone(), agent);
+    }
+
+    agents
+}

codex-rs/core/src/agents/builtins/orchestrator.rs

@@ -0,0 +1,13 @@
+use crate::agents::AgentDefinition;
+
+const PROMPT: &str = include_str!("../../../templates/agents/orchestrator.md");
+
+pub(super) fn definition() -> AgentDefinition {
+    AgentDefinition {
+        name: "orchestrator".to_string(),
+        instructions: Some(PROMPT.to_string()),
+        sub_agents: ["worker", "reviewer", "q_and_a"].iter().map(|s| s.to_string()).collect(),
+        read_only: true,
+        ..Default::default()
+    }
+}

codex-rs/core/src/agents/builtins/q_and_a.rs

@@ -0,0 +1,15 @@
+use codex_protocol::openai_models::ReasoningEffort;
+use crate::agents::AgentDefinition;
+
+const PROMPT: &str = include_str!("../../../templates/agents/q_and_a.md");
+
+pub(super) fn definition() -> AgentDefinition {
+    AgentDefinition {
+        name: "q_and_a".to_string(),
+        instructions: Some(PROMPT.to_string()),
+        read_only: true,
+        model: Some("gpt-5.2".to_string()),
+        reasoning_effort: Some(ReasoningEffort::High),
+        ..Default::default()
+    }
+}

codex-rs/core/src/agents/builtins/reviewer.rs

@@ -0,0 +1,15 @@
+use codex_protocol::openai_models::ReasoningEffort;
+use crate::agents::AgentDefinition;
+
+const PROMPT: &str = include_str!("../../../templates/agents/reviewer.md");
+
+pub(super) fn definition() -> AgentDefinition {
+    AgentDefinition {
+        name: "reviewer".to_string(),
+        instructions: Some(PROMPT.to_string()),
+        read_only: true,
+        model: Some("gpt-5.2".to_string()),
+        reasoning_effort: Some(ReasoningEffort::High),
+        ..Default::default()
+    }
+}

codex-rs/core/src/agents/builtins/worker.rs

@@ -0,0 +1,11 @@
+use crate::agents::AgentDefinition;
+
+const PROMPT: &str = include_str!("../../../gpt-5.1-codex-max_prompt.md");
+
+pub(super) fn definition() -> AgentDefinition {
+    AgentDefinition {
+        name: "worker".to_string(),
+        instructions: Some(PROMPT.to_string()),
+        ..Default::default()
+    }
+}

codex-rs/core/src/agents/mod.rs

@@ -1,3 +1,5 @@
+mod builtins;
+
 use std::collections::HashMap;
 use std::path::Path;
 
@@ -5,7 +7,9 @@ use codex_protocol::openai_models::ReasoningEffort;
 use serde::Deserialize;
 use tracing::warn;
 
-#[derive(Debug, Clone)]
+use builtins::builtin_agents;
+
+#[derive(Debug, Clone, Default)]
 pub(crate) struct AgentDefinition {
     pub(crate) name: String,
     pub(crate) instructions: Option<String>,
@@ -38,26 +42,52 @@ impl AgentsConfig {
     pub(crate) const FILE_NAME: &'static str = "agents.toml";
 
     pub(crate) async fn try_load(codex_home: &Path) -> Option<Self> {
+        let mut agents = builtin_agents();
         let path = codex_home.join(Self::FILE_NAME);
+
         let content = match tokio::fs::read_to_string(&path).await {
-            Ok(content) => content,
-            Err(err) if err.kind() == std::io::ErrorKind::NotFound => return None,
+            Ok(content) => Some(content),
+            Err(err) if err.kind() == std::io::ErrorKind::NotFound => None,
             Err(err) => {
                 warn!("failed to read {}: {err}", path.display());
-                return None;
+                None
             }
         };
 
-        match Self::from_toml_str(&content) {
-            Ok(config) => Some(config),
-            Err(err) => {
-                warn!("failed to parse {}: {err}", path.display());
-                None
+        if let Some(content) = content {
+            match Self::from_toml_str(&content) {
+                Ok(custom_agents) => {
+                    for (name, agent) in custom_agents {
+                        if agents.contains_key(&name) {
+                            warn!(
+                                "duplicate agent definition {name} in {} ignored",
+                                path.display()
+                            );
+                            continue;
+                        }
+                        agents.insert(name, agent);
+                    }
+                }
+                Err(err) => {
+                    warn!("failed to parse {}: {err}", path.display());
+                }
             }
         }
+
+        if let Err(err) = Self::validate_agents(&agents) {
+            warn!("failed to validate {}: {err}", path.display());
+            agents = builtin_agents();
+        }
+
+        if let Err(err) = Self::validate_agents(&agents) {
+            warn!("invalid built-in agents config: {err}");
+            return None;
+        }
+
+        Some(Self { agents })
     }
 
-    fn from_toml_str(contents: &str) -> Result<Self, String> {
+    fn from_toml_str(contents: &str) -> Result<HashMap<String, AgentDefinition>, String> {
         let raw: HashMap<String, RawAgentDefinition> =
             toml::from_str(contents).map_err(|err| format!("invalid toml: {err}"))?;
 
@@ -76,6 +106,7 @@ impl AgentsConfig {
                     Some(instructions)
                 }
             });
+
             agents.insert(
                 name.clone(),
                 AgentDefinition {
@@ -89,6 +120,10 @@ impl AgentsConfig {
             );
         }
 
+        Ok(agents)
+    }
+
+    fn validate_agents(agents: &HashMap<String, AgentDefinition>) -> Result<(), String> {
         if !agents.contains_key("main") {
             return Err("missing required agent: main".to_string());
         }
@@ -97,14 +132,14 @@ impl AgentsConfig {
             for sub in &agent.sub_agents {
                 if !agents.contains_key(sub) {
                     return Err(format!(
-                        "agent {}: unknown sub_agent {sub}",
-                        agent.name.as_str()
+                        "agent {name}: unknown sub_agent {sub}",
+                        name = agent.name.as_str()
                     ));
                 }
             }
         }
 
-        Ok(Self { agents })
+        Ok(())
     }
 
     pub(crate) fn agent(&self, name: &str) -> Option<&AgentDefinition> {
@@ -113,7 +148,7 @@ impl AgentsConfig {
 
     pub(crate) fn main(&self) -> &AgentDefinition {
         self.agents
-            .get("main")
-            .expect("agents config validated main agent")
+            .get("orchestrator")
+            .expect("agents config validated orchestrator agent")
     }
 }

codex-rs/core/src/state/collaboration.rs

@@ -34,8 +34,18 @@ fn content_for_log(message: &ResponseItem) -> String {
     }
 }
 
-#[derive(Clone, Copy, Debug, Eq, PartialEq, Hash)]
-pub(crate) struct AgentId(pub i32);
+#[derive(Clone, Debug, Eq, PartialEq, Hash)]
+pub(crate) struct AgentId(pub String);
+
+impl AgentId {
+    pub fn root() -> Self {
+        Self("root".to_string())
+    }
+
+    pub fn random() -> Self {
+        Self(uuid::Uuid::new_v4().to_string())
+    }
+}
 
 #[allow(dead_code)]
 #[derive(Clone, Debug)]
@@ -82,7 +92,7 @@ impl AgentState {
         instructions: Option<String>,
     ) -> Self {
         Self {
-            id: AgentId(0),
+            id: AgentId::root(),
             name,
             parent: None,
             depth: 0,
@@ -181,7 +191,7 @@ impl CollaborationState {
                     .or_else(|| session_configuration.user_instructions());
             }
         }
-        AgentId(0)
+        AgentId::root()
     }
 
     pub(crate) fn agents(&self) -> &[AgentState] {
@@ -197,10 +207,6 @@ impl CollaborationState {
         self.agents.get_mut(index)
     }
 
-    pub(crate) fn next_agent_id(&self) -> AgentId {
-        AgentId(self.agents.len() as i32)
-    }
-
     pub(crate) fn clone_agent_history(&self, id: AgentId) -> Option<ContextManager> {
         self.agent(id).map(|agent| agent.history.clone())
     }
@@ -267,11 +273,11 @@ impl CollaborationState {
             return Err("max collaboration depth reached".to_string());
         }
 
-        let id = self.next_agent_id();
-        agent.id = id;
+        let id = AgentId::random();
+        agent.id = id.clone();
 
-        if let Some(parent) = agent.parent {
-            self.children.entry(parent).or_default().push(id);
+        if let Some(parent) = agent.parent.as_ref() {
+            self.children.entry(parent.clone()).or_default().push(id.clone());
         }
 
         self.agents.push(agent);

codex-rs/core/src/tasks/collaboration.rs

@@ -33,10 +33,7 @@ pub(crate) struct CollaborationSupervisor {
 #[derive(Debug, Clone)]
 pub(crate) struct AgentRunResult {
     pub(crate) agent: AgentId,
-    pub(crate) delta_tokens: i32,
     pub(crate) status: AgentLifecycleState,
-    pub(crate) last_message: Option<String>,
-    pub(crate) sub_id: Option<String>,
 }
 
 #[derive(Debug)]
@@ -175,10 +172,7 @@ fn ensure_runner(
                 Err(err) => {
                     let _ = events.send(AgentRunResult {
                         agent,
-                        delta_tokens: 0,
                         status: AgentLifecycleState::Error { error: err },
-                        last_message: None,
-                        sub_id: None,
                     });
                 }
             }
@@ -211,10 +205,7 @@ async fn run_agent_turns(
         ) {
             results.push(AgentRunResult {
                 agent: target,
-                delta_tokens: 0,
                 status: agent_snapshot.status,
-                last_message: None,
-                sub_id: None,
             });
             break;
         }
@@ -238,8 +229,6 @@ async fn run_agent_turns(
         let tracker: SharedTurnDiffTracker =
             Arc::new(tokio::sync::Mutex::new(TurnDiffTracker::new()));
         let mut agent_status = AgentLifecycleState::Running;
-        let mut last_message: Option<String> = None;
-
         let before_tokens = agent_history.get_total_token_usage();
         let run_result = run_collaboration_turn(
             Arc::clone(&session),
@@ -271,7 +260,6 @@ async fn run_agent_turns(
                         agent.history = new_history.clone();
                     }
                 }
-                last_message = last;
                 (delta_tokens, needs_follow_up)
             }
             Err(err) => {
@@ -304,10 +292,7 @@ async fn run_agent_turns(
 
         results.push(AgentRunResult {
             agent: target,
-            delta_tokens: delta_tokens.clamp(0, i32::MAX),
             status: final_status,
-            last_message,
-            sub_id: Some(sub_id),
         });
 
         keep_running |= continue_running && remaining_budget > 0;

codex-rs/core/templates/agents/orchestrator.md

@@ -0,0 +1,84 @@
+You are a Codex Orchestrator, based on GPT-5. You are running as a coding agent in the Codex CLI on a user's computer.
+
+## Role
+Your role is not to solve a task but to use other agents to solve it. For this, you can use the collaboration tool to start and communicate with sub-agents
+
+A part of your role is to make sure that the task is properly done. For this:
+* Always ask a reviewer to review the task. If the reviewer finds some issue, iterate with your workers and the reviewer to have something perfect.
+* If an agents stops working but is not fully done, it is your role to ask the same agent or a new one to finish the task.
+
+## Agents
+* `worker`: this agent is the actual worker that can code and complete task. If a task is large or has different scopes, you can split the work between multiple workers.
+* `reviewer`: this agent review the task completion. You must *always* spawn new reviewers (do not re-use old reviewers) and state what was the goal of the task when asking for a review.
+* `q_and_a`: this agent is good to answer questions about the codebase. You can use it for your understanding or to answer questions of other agents. Do not reuse the same q_and_a agent for totally different questions.
+
+## Collaboration
+You can spawn and coordinate child agents using these tools:
+- `collaboration_init_agent`: create a direct child by agent profile name. `agent` defaults to the caller’s agent type; `context_strategy` and `message` are optional. If you pass a non-empty `message`, the child starts immediately; otherwise follow with `collaboration_send`.
+- `collaboration_send`: send a user-message to your direct children by id (string). You can only send messages to previously initialized agents using `collaboration_init_agent`. If the target child is already running, the call fails; `wait` first.
+- `collaboration_wait`: wait up to `max_duration` milliseconds (wall time) for running children to finish and surface their latest state. You can only wait on direct child agents (optionally specify `agent_idx`).
+- `collaboration_get_state`: see the calling agent’s direct children (or a provided `agent_idx` list), their statuses, and latest messages via `state`.
+- `collaboration_close`: close specific children (and their descendants). Use `return_states` if you want the pre-close states.
+
+If you did not include a `message` in `collaboration_init_agent`, follow with `collaboration_send` to start the child agent working.
+
+## Plan tool
+
+When using the planning tool:
+- Skip using the planning tool for straightforward tasks (roughly the easiest 25%).
+- Do not make single-step plans.
+- When you made a plan, update it after having performed one of the sub-tasks that you shared on the plan.
+
+## Special user requests
+
+- If the user makes a simple request (such as asking for the time) which you can fulfill by running a terminal command (such as `date`), you should do so.
+- If the user asks for a "review", default to a code review mindset: prioritise identifying bugs, risks, behavioural regressions, and missing tests. Findings must be the primary focus of the response - keep summaries or overviews brief and only after enumerating the issues. Present findings first (ordered by severity with file/line references), follow with open questions or assumptions, and offer a change-summary only as a secondary detail. If no findings are discovered, state that explicitly and mention any residual risks or testing gaps.
+
+## Frontend tasks
+When doing frontend design tasks, avoid collapsing into "AI slop" or safe, average-looking layouts.
+Aim for interfaces that feel intentional, bold, and a bit surprising.
+- Typography: Use expressive, purposeful fonts and avoid default stacks (Inter, Roboto, Arial, system).
+- Color & Look: Choose a clear visual direction; define CSS variables; avoid purple-on-white defaults. No purple bias or dark mode bias.
+- Motion: Use a few meaningful animations (page-load, staggered reveals) instead of generic micro-motions.
+- Background: Don't rely on flat, single-color backgrounds; use gradients, shapes, or subtle patterns to build atmosphere.
+- Overall: Avoid boilerplate layouts and interchangeable UI patterns. Vary themes, type families, and visual languages across outputs.
+- Ensure the page loads properly on both desktop and mobile
+
+Exception: If working within an existing website or design system, preserve the established patterns, structure, and visual language.
+
+## Presenting your work and final message
+
+You are producing plain text that will later be styled by the CLI. Follow these rules exactly. Formatting should make results easy to scan, but not feel mechanical. Use judgment to decide how much structure adds value.
+
+- Default: be very concise; friendly coding teammate tone.
+- Ask only when needed; suggest ideas; mirror the user's style.
+- For substantial work, summarize clearly; follow final‑answer formatting.
+- Skip heavy formatting for simple confirmations.
+- Don't dump large files you've written; reference paths only.
+- No "save/copy this file" - User is on the same machine.
+- Offer logical next steps (tests, commits, build) briefly; add verify steps if you couldn't do something.
+- For code changes:
+    * Lead with a quick explanation of the change, and then give more details on the context covering where and why a change was made. Do not start this explanation with "summary", just jump right in.
+    * If there are natural next steps the user may want to take, suggest them at the end of your response. Do not make suggestions if there are no natural next steps.
+    * When suggesting multiple options, use numeric lists for the suggestions so the user can quickly respond with a single number.
+- The user does not command execution outputs. When asked to show the output of a command (e.g. `git show`), relay the important details in your answer or summarize the key lines so the user understands the result.
+
+### Final answer structure and style guidelines
+
+- Plain text; CLI handles styling. Use structure only when it helps scanability.
+- Headers: optional; short Title Case (1-3 words) wrapped in **…**; no blank line before the first bullet; add only if they truly help.
+- Bullets: use - ; merge related points; keep to one line when possible; 4–6 per list ordered by importance; keep phrasing consistent.
+- Monospace: backticks for commands/paths/env vars/code ids and inline examples; use for literal keyword bullets; never combine with **.
+- Code samples or multi-line snippets should be wrapped in fenced code blocks; include an info string as often as possible.
+- Structure: group related bullets; order sections general → specific → supporting; for subsections, start with a bolded keyword bullet, then items; match complexity to the task.
+- Tone: collaborative, concise, factual; present tense, active voice; self‑contained; no "above/below"; parallel wording.
+- Don'ts: no nested bullets/hierarchies; no ANSI codes; don't cram unrelated keywords; keep keyword lists short—wrap/reformat if long; avoid naming formatting styles in answers.
+- Adaptation: code explanations → precise, structured with code refs; simple tasks → lead with outcome; big changes → logical walkthrough + rationale + next actions; casual one-offs → plain sentences, no headers/bullets.
+- File References: When referencing files in your response follow the below rules:
+    * Use inline code to make file paths clickable.
+    * Each reference should have a stand alone path. Even if it's the same file.
+    * Accepted: absolute, workspace‑relative, a/ or b/ diff prefixes, or bare filename/suffix.
+    * Optionally include line/column (1‑based): :line[:column] or #Lline[Ccolumn] (column defaults to 1).
+    * Do not use URIs like file://, vscode://, or https://.
+    * Do not provide range of lines
+    * Examples: src/app.ts, src/app.ts:42, b/server/index.js#L10, C:\repo\project\main.rs:12:5

codex-rs/core/templates/agents/q_and_a.md

@@ -0,0 +1,5 @@
+You are a Q&A agent.
+- Answer questions clearly and directly.
+- Provide concise explanations or examples.
+- Do not modify code.
+- You can explore the codebase as you please as well as the git history to answer the questions.

codex-rs/core/templates/agents/reviewer.md

@@ -0,0 +1,87 @@
+# 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.
+
+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 FORMAT:
+
+## Output schema  — MUST MATCH *exactly*
+
+```json
+{
+  "findings": [
+    {
+      "title": "<≤ 80 chars, imperative>",
+      "body": "<valid Markdown explaining *why* this is a problem; cite files/lines/functions>",
+      "confidence_score": <float 0.0-1.0>,
+      "priority": <int 0-3, optional>,
+      "code_location": {
+        "absolute_file_path": "<file path>",
+        "line_range": {"start": <int>, "end": <int>}
+      }
+    }
+  ],
+  "overall_correctness": "patch is correct" | "patch is incorrect",
+  "overall_explanation": "<1-3 sentence explanation justifying the overall_correctness verdict>",
+  "overall_confidence_score": <float 0.0-1.0>
+}
+```
+
+* **Do not** wrap the JSON in markdown fences or extra prose.
+* The code_location field is required and must include absolute_file_path and line_range.
+* Line ranges must be as short as possible for interpreting the issue (avoid ranges over 5–10 lines; pick the most suitable subrange).
+* The code_location should overlap with the diff.
+* Do not generate a PR fix.