refactor(agent): expose codebase result caps as per-knob ToolPolicy fields

Replace ToolPolicy::codebase_result_caps (single bool, hardcoded 20/2048/50
constants in codebase_search.rs + codebase_graph.rs) with three Option fields:

  codebase_search_limit:       Option<u32>     (None = no default-limit injection)
  codebase_search_chunk_bytes: Option<usize>   (None = no content cap)
  codebase_graph_section_cap:  Option<usize>   (None = no section cap)

ToolPolicy::bench() still resolves to the same effective values (Some(20)
/ Some(2048) / Some(50)) so existing behavior is byte-identical. The
refactor enables bench-runner to tune these from CLI flags / env vars in
the next commit without rebuilding the binary.

Author: adithyn7

crates/agent/src/tool/codebase_graph.rs

@@ -7,9 +7,6 @@ use crate::context_engine::ContextEngineApi;
 use crate::error::ToolError;
 use super::{Tool, ToolContext, ToolResult};
 
-/// Max rows rendered per graph section (callers / deps / related) under bench policy.
-const GRAPH_SECTION_CAP: usize = 50;
-
 pub struct CodebaseGraphTool {
     context_engine: Arc<dyn ContextEngineApi>,
 }
@@ -77,12 +74,9 @@ impl Tool for CodebaseGraphTool {
         }
 
         // Bench policy: cap each rendered section so a high-degree node doesn't dump
-        // hundreds of rows into the context. No-op (unbounded) under the app policy.
-        let section_cap = if ctx.policy.codebase_result_caps {
-            GRAPH_SECTION_CAP
-        } else {
-            usize::MAX
-        };
+        // hundreds of rows into the context. No-op (unbounded) under the app policy
+        // when `codebase_graph_section_cap` is None.
+        let section_cap = ctx.policy.codebase_graph_section_cap.unwrap_or(usize::MAX);
 
         log::info!(
             "[codebase_graph] query={:?}, function_name={:?}, file_path={:?}, query_type={:?}",

crates/agent/src/tool/codebase_search.rs

@@ -10,18 +10,13 @@ use crate::context_engine::{ContextEngineApi, SearchResultItem};
 use crate::error::ToolError;
 use super::{Tool, ToolContext, ToolResult};
 
-/// Default result count when the model omits `limit` (bench policy only).
-const DEFAULT_SEARCH_LIMIT: u32 = 20;
-/// Max bytes of chunk content rendered per result (bench policy only).
-const MAX_CHUNK_BYTES: usize = 2048;
-
-/// Truncate a chunk's content to `MAX_CHUNK_BYTES` on a UTF-8 boundary, appending a
+/// Truncate a chunk's content to `max_bytes` on a UTF-8 boundary, appending a
 /// marker when clipped. Keeps oversized index payloads from ballooning the context.
-fn cap_chunk_content(content: &str) -> String {
-    if content.len() <= MAX_CHUNK_BYTES {
+fn cap_chunk_content(content: &str, max_bytes: usize) -> String {
+    if content.len() <= max_bytes {
         return content.to_string();
     }
-    let mut end = MAX_CHUNK_BYTES;
+    let mut end = max_bytes;
     while !content.is_char_boundary(end) {
         end -= 1;
     }
@@ -89,12 +84,15 @@ impl Tool for CodebaseSearchTool {
         let strategy = args.get("strategy").and_then(|v| v.as_str());
         let mut limit = args.get("limit").and_then(|v| v.as_u64().map(|n| n as u32));
 
-        // Bench policy: when the model omits `limit`, default to 20 so the engine
-        // doesn't return a huge result set that balloons the conversation. The model
-        // can still page by raising the existing `limit` param. No-op under app policy.
-        let caps = ctx.policy.codebase_result_caps;
-        if caps && limit.is_none() {
-            limit = Some(DEFAULT_SEARCH_LIMIT);
+        // Bench policy: when the model omits `limit`, default to the policy value so
+        // the engine doesn't return a huge result set that balloons the conversation.
+        // The model can still page by raising the existing `limit` param. No-op under
+        // app policy (codebase_search_limit = None).
+        let policy_limit = ctx.policy.codebase_search_limit;
+        if let Some(l) = policy_limit {
+            if limit.is_none() {
+                limit = Some(l);
+            }
         }
 
         log::info!(
@@ -158,12 +156,12 @@ impl Tool for CodebaseSearchTool {
         // Bench policy: cap result count (defensive — the engine may ignore `limit`)
         // and cap each chunk's content so oversized payloads don't inflate every
         // subsequent turn's context. No-op under the default (app) policy.
-        if caps {
-            if let Some(l) = limit {
-                results.truncate(l as usize);
-            }
+        if let Some(l) = policy_limit {
+            results.truncate(l as usize);
+        }
+        if let Some(max_bytes) = ctx.policy.codebase_search_chunk_bytes {
             for item in results.iter_mut() {
-                item.content = cap_chunk_content(&item.content);
+                item.content = cap_chunk_content(&item.content, max_bytes);
             }
         }
 

crates/agent/src/tool/mod.rs

@@ -97,8 +97,16 @@ pub struct ToolPolicy {
     pub search_timeout_ms: Option<u64>,
     /// Skip the default ignore-dir list in grep/glob. `false` = no extra ignores (app default).
     pub search_default_ignores: bool,
-    /// Apply codebase_search/graph result + content caps. `false` = no caps (app default).
-    pub codebase_result_caps: bool,
+    /// Default `limit` for codebase_search when the model omits it; the same value
+    /// also bounds the final result count. `None` = pass through, no default,
+    /// no truncation (app default).
+    pub codebase_search_limit: Option<u32>,
+    /// Cap per-chunk content bytes in codebase_search results (UTF-8 boundary +
+    /// `…[truncated]` marker). `None` = no cap (app default).
+    pub codebase_search_chunk_bytes: Option<usize>,
+    /// Cap rows rendered per codebase_graph section (callers / deps / related);
+    /// truncated sections append `… and N more`. `None` = no cap (app default).
+    pub codebase_graph_section_cap: Option<usize>,
 }
 
 impl Default for ToolPolicy {
@@ -108,20 +116,25 @@ impl Default for ToolPolicy {
             bash_timeout_ceiling_ms: None,
             search_timeout_ms: None,
             search_default_ignores: false,
-            codebase_result_caps: false,
+            codebase_search_limit: None,
+            codebase_search_chunk_bytes: None,
+            codebase_graph_section_cap: None,
         }
     }
 }
 
 impl ToolPolicy {
     /// Strict policy for the eval harness: bash clamped to 300s, grep/glob walled at
-    /// 60s and skipping build/vendor dirs, codebase_* results capped.
+    /// 60s and skipping build/vendor dirs, codebase_search ≤20 results × ≤2KB/chunk,
+    /// codebase_graph ≤50 rows per section.
     pub fn bench() -> Self {
         Self {
             bash_timeout_ceiling_ms: Some(300_000),
             search_timeout_ms: Some(60_000),
             search_default_ignores: true,
-            codebase_result_caps: true,
+            codebase_search_limit: Some(20),
+            codebase_search_chunk_bytes: Some(2048),
+            codebase_graph_section_cap: Some(50),
         }
     }
 }