Cloud kimi-k2.5 executor for weak tiers + multi-strategy playbook retrieval

Two coupled changes from the 2026 agent-memory research + tool
asymmetry findings.

SCENARIO (weak-tier cloud substitute):
qwen2.5 collapsed to 0/14 across the basic/minimal tool_levels.
Replace with cloud kimi-k2.5 on Ollama Cloud — same family as k2.6
(pro-tier locked today, on J's upgrade path). Plumb cloud flag
through ACTIVE_EXECUTOR_CLOUD / ACTIVE_REVIEWER_CLOUD into
generateContinuable so executor/reviewer can route to cloud when
tool_level requires. think:false supported by Kimi family.

Tool level mapping (revised):
  full     — qwen3.5 local + qwen3 local + cloud gpt-oss:120b T3 + rescue
  local    — qwen3.5 local + qwen3 local + local gpt-oss:20b T3 + rescue
  basic    — kimi-k2.5 cloud + qwen3 local + local T3, no rescue
  minimal  — kimi-k2.5 cloud + qwen3 local, no T3, no rescue.
             Playbook inheritance alone on the decision path.

This is the honest version of J's "minimal tools still works via
inheritance" hypothesis — with the executor no longer broken at the
tokenizer level, we can actually measure whether playbook retrieval
substitutes for missing overseers.

PLAYBOOK_MEMORY (multi-strategy retrieval):
Zep / Mem0 research shows multi-strategy rerank (semantic + keyword +
graph + temporal) outperforms single-strategy cosine. Lakehouse now
has a two-tier:

  1. Exact (role, city, state) match: skip cosine, assign similarity=1.0,
     take up to top_k/2+1 slots. These are identity-class neighbors —
     the strongest possible signal.
  2. Cosine fallback within the same (city, state) but different role:
     fills remaining slots.

Exposed as compute_boost_for_filtered_with_role(target_geo, target_role).
Backwards-compatible: compute_boost_for_filtered forwards with role=None
so existing callers keep their current behavior.

Service.rs wires both: extract_target_geo and extract_target_role pull
from the executor's SQL filter. grab_eq_value is factored out of
extract_target_geo so both lookups share one parser. Diagnostic log
now prints target_role alongside target_geo for every hybrid_search:

  playbook_boost: boosts=88 sources=39 parsed=39 matched=5
    target_geo=Some(("Nashville", "TN")) target_role=Some("Welder")

Verified: Nashville Welder query returns 5/10 boosted workers in
top_k with clean role+geo provenance.

Research sources: atlan.com Agent Memory Frameworks 2026, Mem0 paper
(arxiv 2504.19413), Zep/Graphiti LongMemEval comparison, ossinsight
Agent Memory Race 2026.

kimi-k2.6 on current key returns 403 — pro-tier upgrade required.
kimi-k2.5 is the substitute today; swap to k2.6 by renaming one line
in applyToolLevel once the subscription lands.

crates/vectord/src/service.rs

@@ -803,20 +803,23 @@ async fn hybrid_search(
     // set. Additive boost on the existing vector score, then re-sort.
     if req.use_playbook_memory {
         let boost_k = req.playbook_memory_k.unwrap_or(playbook_memory::DEFAULT_TOP_K_PLAYBOOKS);
-        // Extract target (city, state) from the SQL filter so
-        // compute_boost_for can skip playbooks from other cities that
-        // would never intersect the candidate pool. The executor's
-        // filter shape is stable: `... city = 'Toledo' AND state = 'OH' ...`.
-        // Case-insensitive match, tolerant of single quotes and spaces.
+        // Extract target (city, state, role) from the SQL filter so
+        // compute_boost_for can skip playbooks from other cities AND
+        // prioritize exact role matches via the multi-strategy path.
+        // The executor's filter shape is stable:
+        //   `... role = 'Welder' AND city = 'Toledo' AND state = 'OH' ...`.
+        // Case-insensitive match, tolerant of single quotes.
         let target_geo = req.sql_filter.as_deref().and_then(extract_target_geo);
+        let target_role = req.sql_filter.as_deref().and_then(extract_target_role);
         // We embedded the question as `qv` above — reuse it for the
         // playbook similarity lookup so we don't double-pay Ollama.
         let boosts = state.playbook_memory
-            .compute_boost_for_filtered(
+            .compute_boost_for_filtered_with_role(
                 &qv,
                 boost_k,
                 0.5,
                 target_geo.as_ref().map(|(c, s)| (c.as_str(), s.as_str())),
+                target_role.as_deref(),
             )
             .await;
 
@@ -850,12 +853,13 @@ async fn hybrid_search(
             }
         }
         tracing::info!(
-            "playbook_boost: boosts={} sources={} parsed={} matched={} target_geo={:?} (query='{}')",
+            "playbook_boost: boosts={} sources={} parsed={} matched={} target_geo={:?} target_role={:?} (query='{}')",
             boosts.len(),
             sources.len(),
             parsed_count,
             matched_count,
             target_geo,
+            target_role,
             req.question.chars().take(60).collect::<String>(),
         );
         // Re-rank: boosted scores can flip ordering.
@@ -2098,51 +2102,53 @@ struct LanceRecallQuery {
 /// "{Name} — {Role} in {City}, {State}. Skills: …".
 /// Returns None if the chunk doesn't match the shape; callers simply
 /// skip the boost for that hit.
+/// Extract role from an SQL filter matching `role = 'Welder'` style.
+/// Case-insensitive on the column name. Quoted value; quotes not
+/// included in returned string.
+fn extract_target_role(sql_filter: &str) -> Option<String> {
+    grab_eq_value(sql_filter, "role")
+}
+
+/// Shared equality-value extractor for (city, state, role) lookups.
+fn grab_eq_value(src: &str, col: &str) -> Option<String> {
+    let lower = src.to_ascii_lowercase();
+    let col_lower = col.to_ascii_lowercase();
+    let mut search_from = 0usize;
+    while let Some(off) = lower[search_from..].find(&col_lower) {
+        let pos = search_from + off;
+        let prior_ok = pos == 0
+            || !lower.as_bytes()[pos - 1].is_ascii_alphanumeric()
+               && lower.as_bytes()[pos - 1] != b'_';
+        let after = pos + col_lower.len();
+        if !prior_ok || after >= src.len() {
+            search_from = pos + col_lower.len();
+            continue;
+        }
+        let mut i = after;
+        while i < src.len() && src.as_bytes()[i] == b' ' { i += 1; }
+        if i >= src.len() || src.as_bytes()[i] != b'=' { search_from = pos + col_lower.len(); continue; }
+        i += 1;
+        while i < src.len() && src.as_bytes()[i] == b' ' { i += 1; }
+        if i >= src.len() || src.as_bytes()[i] != b'\'' { search_from = pos + col_lower.len(); continue; }
+        i += 1;
+        let start = i;
+        while i < src.len() && src.as_bytes()[i] != b'\'' { i += 1; }
+        if i > start {
+            return Some(src[start..i].to_string());
+        }
+        search_from = pos + col_lower.len();
+    }
+    None
+}
+
 /// Pull (city, state) out of a SQL filter that uses
 /// `city = 'Toledo' AND state = 'OH'` style equality. Returns None if
 /// either is missing — the caller keeps the original global boost map
 /// behavior (no geo narrowing). Case-insensitive on the column name
 /// so `CITY=` or `City =` also work.
 fn extract_target_geo(sql_filter: &str) -> Option<(String, String)> {
-    fn grab_eq(src: &str, col: &str) -> Option<String> {
-        // Very small parser, resilient enough for the executor's
-        // filter shapes. Matches `col = 'value'` or `col='value'` with
-        // case-insensitive column name.
-        let lower = src.to_ascii_lowercase();
-        let col_lower = col.to_ascii_lowercase();
-        let mut search_from = 0usize;
-        while let Some(off) = lower[search_from..].find(&col_lower) {
-            let pos = search_from + off;
-            // Require word boundary before the column name so "city"
-            // inside "civilian_rank" doesn't false-match.
-            let prior_ok = pos == 0
-                || !lower.as_bytes()[pos - 1].is_ascii_alphanumeric()
-                   && lower.as_bytes()[pos - 1] != b'_';
-            let after = pos + col_lower.len();
-            if !prior_ok || after >= src.len() {
-                search_from = pos + col_lower.len();
-                continue;
-            }
-            // Walk past whitespace, require '='.
-            let mut i = after;
-            while i < src.len() && src.as_bytes()[i] == b' ' { i += 1; }
-            if i >= src.len() || src.as_bytes()[i] != b'=' { search_from = pos + col_lower.len(); continue; }
-            i += 1;
-            while i < src.len() && src.as_bytes()[i] == b' ' { i += 1; }
-            // Value is single-quoted literal; extract until the next '.
-            if i >= src.len() || src.as_bytes()[i] != b'\'' { search_from = pos + col_lower.len(); continue; }
-            i += 1;
-            let start = i;
-            while i < src.len() && src.as_bytes()[i] != b'\'' { i += 1; }
-            if i > start {
-                return Some(src[start..i].to_string());
-            }
-            search_from = pos + col_lower.len();
-        }
-        None
-    }
-    let city = grab_eq(sql_filter, "city")?;
-    let state = grab_eq(sql_filter, "state")?;
+    let city = grab_eq_value(sql_filter, "city")?;
+    let state = grab_eq_value(sql_filter, "state")?;
     Some((city, state))
 }