(MOT-4951) feat(ide): coder::find-relevant — judge-ranked code discovery (jevgrep port)

harness/prompts/default.txt

@@ -287,7 +287,9 @@ served by the shell worker (no separate install). Confirm they are available wit
 `engine::functions::list { prefix: "coder::" }`. Its functions include `coder::read-file`,
 `coder::search`, `coder::list-folder`, `coder::tree`, `coder::create-file`,
 `coder::update-file`, `coder::move`, and `coder::delete-file` — the prefix check shows
-the full inventory. Use `coder::move` for renames and moves, never delete-then-recreate. Plain
+the full inventory. For how/where/why questions, start with `coder::find-relevant` (pass
+the component folder as `path`); use `coder::search` for exact symbols, strings or filenames.
+Use `coder::move` for renames and moves, never delete-then-recreate. Plain
 file browsing outside code work (like `shell::fs::ls`) is still fine. Fetch each contract
 first, as always.
 

harness/src/functions/function_resolve.rs

@@ -51,5 +51,10 @@ pub async fn handle(
     deps: &Deps,
     req: FunctionResolveRequest,
 ) -> Result<FunctionResolveResponse, HarnessError> {
-    crate::deferred::resolve(deps, req).await
+    // A resolve runs outside the turn step: a released held call (e.g. an
+    // approved `coder::find-relevant`) and the result's reconciliation keep
+    // the session's judge instead of the hub default or the caller's.
+    let session_id = req.session_id.clone();
+    crate::judge::with_session_provider(deps, &session_id, crate::deferred::resolve(deps, req))
+        .await
 }

harness/src/functions/function_trigger.rs

@@ -67,9 +67,20 @@ pub enum FunctionTriggerResponse {
     Pending(TriggerPendingResponse),
 }
 
+/// A direct call runs outside the turn step, under the session's judge
+/// provider as the step would be.
 pub async fn handle(
     deps: &Deps,
     req: FunctionTriggerRequest,
+) -> Result<FunctionTriggerResponse, HarnessError> {
+    let session_id = req.session_id.clone();
+    // Boxed: the pipeline's future is large for a caller's stack.
+    crate::judge::with_session_provider(deps, &session_id, Box::pin(trigger_call(deps, req))).await
+}
+
+async fn trigger_call(
+    deps: &Deps,
+    req: FunctionTriggerRequest,
 ) -> Result<FunctionTriggerResponse, HarnessError> {
     let _guard = deps.locks.guard(&req.session_id).await;
     super::delete_session_tree::ensure_live(deps, &req.session_id).await?;

harness/src/functions/turn.rs

@@ -63,22 +63,21 @@ pub async fn handle(deps: &Deps, payload: TurnStepPayload) -> Result<TurnStepRes
     if let Some(display_name) = subagent_display_name.as_deref() {
         baggage.push(("iii.tag.display_name", display_name));
     }
-    // The session's judge provider rides the turn's context: every judge call
-    // this turn causes (call reconciliation here, function search in the
-    // directory, browser::run) routes to it, and other sessions never see it.
-    if let Some(provider) = hints.judge_provider.as_deref() {
-        baggage.push((judge_contract::PROVIDER_BAGGAGE_KEY, provider));
-    }
     // The explicit step span matters: the baggage only materializes as span
     // attributes when a span STARTS inside this scope, and downstream workers
     // may run older SDKs whose processors drop the newer keys. This span is
     // ours, so the turn's trace always carries the tags — and the session::*
     // / router client calls parent under it instead of dangling.
-    iii_helpers::observability::run_with_baggage(&baggage, async {
+    //
+    // The session's judge provider rides the turn's context: every judge call
+    // this turn causes (call reconciliation here, function search in the
+    // directory, browser::run) routes to it, and a session without one drops
+    // whatever provider the step's enqueuer carried.
+    let step = iii_helpers::observability::run_with_baggage(&baggage, async {
         iii_helpers::observability::run_in_span("harness::turn step", None, || run(deps, payload))
             .await
-    })
-    .await
+    });
+    crate::judge::with_provider(hints.judge_provider, step).await
 }
 
 /// Bounded in-place retry budget for step errors that mean a dependency is

harness/src/judge.rs

@@ -39,6 +39,44 @@ const SECRET_KEYS: [&str; 11] = [
 /// failing judge never pauses another session's.
 static PAUSED_UNTIL: Mutex<BTreeMap<String, i64>> = Mutex::new(BTreeMap::new());
 
+/// Run `future` under `session_id`'s judge provider, as its turn step does:
+/// work outside the step (a released held call, a direct
+/// `harness::function::trigger`) keeps the session's judge.
+pub(crate) async fn with_session_provider<T>(
+    deps: &Deps,
+    session_id: &str,
+    future: impl std::future::Future<Output = T>,
+) -> T {
+    let provider = deps
+        .session()
+        .await
+        .turn_hints(session_id)
+        .await
+        .judge_provider;
+    with_provider(provider, future).await
+}
+
+/// Run `future` with `provider` as its only judge provider. `None` clears
+/// any provider the caller's context carried, so a caller never picks the
+/// judge a session call uses.
+pub(crate) async fn with_provider<T>(
+    provider: Option<String>,
+    future: impl std::future::Future<Output = T>,
+) -> T {
+    use iii_helpers::observability::opentelemetry::{
+        baggage::BaggageExt as _, trace::FutureExt as _, Context, KeyValue,
+    };
+    let context = Context::current();
+    let mut entries: Vec<KeyValue> = context
+        .baggage()
+        .iter()
+        .filter(|(key, _)| key.as_str() != judge_contract::PROVIDER_BAGGAGE_KEY)
+        .map(|(key, (value, _))| KeyValue::new(key.clone(), value.clone()))
+        .collect();
+    entries.extend(provider.map(|p| KeyValue::new(judge_contract::PROVIDER_BAGGAGE_KEY, p)));
+    future.with_context(context.with_baggage(entries)).await
+}
+
 /// The current turn's judge provider (`judge_contract::PROVIDER_BAGGAGE_KEY`
 /// baggage stamped by the turn step), when set and well-formed.
 pub(crate) fn current_provider() -> Option<String> {

harness/src/prompt/tests.rs

@@ -355,6 +355,7 @@ fn coder_routing() {
         assert!(out.contains(id), "missing {id}");
     }
     assert!(out.contains("the full inventory"));
+    assert!(out.contains("start with `coder::find-relevant`"));
     assert!(out.contains("never delete-then-recreate"));
 }
 

harness/tests/delete_session_tree.rs

@@ -21,6 +21,8 @@ struct Store {
     sessions: BTreeMap<String, Value>,
     messages: BTreeMap<String, Vec<Value>>,
     calls: Vec<(String, Value)>,
+    /// The W3C `baggage` header each call carried, in call order.
+    baggage: Vec<(String, Value)>,
     fail: BTreeSet<String>,
     fail_delete: Option<String>,
     delete_reply: Option<Value>,
@@ -198,6 +200,9 @@ impl Stack {
                 let function = message["function_id"].as_str().unwrap();
                 let (result, code) = {
                     let mut store = state.lock().unwrap();
+                    store
+                        .baggage
+                        .push((function.into(), message["baggage"].clone()));
                     let code = store
                         .codes
                         .get(function)
@@ -1561,6 +1566,124 @@ async fn a_released_call_keeps_the_boundary_its_holder_reviewed() {
     assert_eq!(payload["fs_scope"]["boundary"], "workspace", "{payload}");
 }
 
+/// The `iii.judge.provider` baggage the call to `function_id` carried.
+fn stamped_provider(stack: &Stack, function_id: &str) -> Option<String> {
+    let store = stack.store.lock().unwrap();
+    let (_, baggage) = store
+        .baggage
+        .iter()
+        .find(|(f, _)| f == function_id)
+        .expect("the call is dispatched");
+    baggage
+        .as_str()
+        .unwrap_or_default()
+        .split(',')
+        .find_map(|entry| entry.trim().strip_prefix("iii.judge.provider="))
+        .map(str::to_string)
+}
+
+/// Calls made outside the turn step (an approved held call, a direct
+/// `harness::function::trigger`) keep the session's judge provider, and a
+/// caller's own provider never reaches them: without it a
+/// `coder::find-relevant` asks another judge than the session chose.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn calls_outside_the_turn_step_use_the_session_judge_provider() {
+    for provider in [Some("clef"), None] {
+        let stack = Stack::new("completed").await;
+        {
+            let mut store = stack.store.lock().unwrap();
+            if let Some(provider) = provider {
+                let meta = store.sessions.get_mut("child1").unwrap();
+                meta["metadata"]["judge_provider"] = json!(provider);
+            }
+            let mut turn = store.state("harness_turn", "child1");
+            turn["status"] = json!("awaiting_functions");
+            turn["options"]["functions"] = json!({"allow": ["coder::*"]});
+            turn["calls"] = json!({"held-1": {
+                "state": "pending",
+                "function_id": "coder::find-relevant",
+                "held_by": "gone::gate",
+                "held_arguments": {"query": "where are retries decided?"}
+            }});
+            store.put("harness_turn", "child1", turn);
+        }
+        // the caller's own context names another provider
+        let ambient = [("iii.judge.provider", "ambient")];
+        let resolved = iii_helpers::observability::run_with_baggage(
+            &ambient,
+            // Boxed: both handlers' futures inline overflow the default 2 MiB
+            // test-thread stack.
+            Box::pin(harness::functions::function_resolve::handle(
+                &stack.deps,
+                serde_json::from_value(json!({
+                    "session_id": "child1",
+                    "turn_id": "t_child1",
+                    "function_call_id": "held-1",
+                    "action": "execute"
+                }))
+                .unwrap(),
+            )),
+        )
+        .await
+        .unwrap();
+        assert!(resolved.resolved, "{provider:?}");
+        assert_eq!(
+            stamped_provider(&stack, "coder::find-relevant").as_deref(),
+            provider
+        );
+
+        iii_helpers::observability::run_with_baggage(
+            &ambient,
+            Box::pin(harness::functions::function_trigger::handle(
+                &stack.deps,
+                serde_json::from_value(json!({
+                    "session_id": "child1",
+                    "call": {
+                        "id": "direct-1",
+                        "function_id": "coder::search",
+                        "arguments": {"query": "retries"}
+                    }
+                }))
+                .unwrap(),
+            )),
+        )
+        .await
+        .unwrap();
+        assert_eq!(
+            stamped_provider(&stack, "coder::search").as_deref(),
+            provider
+        );
+    }
+}
+
+/// The turn step routes its calls to the session's judge provider, and a
+/// step whose enqueuer carried a provider drops it for a session without
+/// one: otherwise in-step calls and released held calls ask different judges.
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn the_turn_step_uses_only_the_session_judge_provider() {
+    for provider in [Some("clef"), None] {
+        let stack = Stack::new("completed").await;
+        if let Some(provider) = provider {
+            let mut store = stack.store.lock().unwrap();
+            let meta = store.sessions.get_mut("child1").unwrap();
+            meta["metadata"]["judge_provider"] = json!(provider);
+        }
+        // Stops at the mock's context::assemble boundary.
+        let _ = iii_helpers::observability::run_with_baggage(
+            &[("iii.judge.provider", "ambient")],
+            Box::pin(harness::functions::turn::handle(
+                &stack.deps,
+                step("child1"),
+            )),
+        )
+        .await;
+        assert_eq!(
+            stamped_provider(&stack, "context::assemble").as_deref(),
+            provider
+        );
+    }
+}
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn ordinary_stop_persists_abort_on_router_failure_but_deletion_fails_closed() {
     for code in ["test_error", "function_not_found"] {