chore(release): 1.21.1 [skip ci]

## [1.21.1](https://github.com/asepharyana/zesdex/compare/v1.21.0...v1.21.1) (2026-08-28)

### Bug Fixes

* **agent:** semantic_search symbol index workspace-aware ([104af3a](https://github.com/asepharyana/zesdex/commit/104af3abb9e626c5d00ea87d523248d606d523ee))

CHANGELOG.md

@@ -1,3 +1,31 @@
+## [1.21.1](https://github.com/asepharyana/zesdex/compare/v1.21.0...v1.21.1) (2026-08-28)
+
+
+### Bug Fixes
+
+* **agent:** semantic_search symbol index workspace-aware ([104af3a](https://github.com/asepharyana/zesdex/commit/104af3abb9e626c5d00ea87d523248d606d523ee))
+
+# [1.21.0](https://github.com/asepharyana/zesdex/compare/v1.20.2...v1.21.0) (2026-08-28)
+
+
+### Features
+
+* **agent:** hive-mind consensus synthesis pakai LLM nyata ([f75ff74](https://github.com/asepharyana/zesdex/commit/f75ff740ac2fa63340656e1e8215440f5e48063d))
+
+## [1.20.2](https://github.com/asepharyana/zesdex/compare/v1.20.1...v1.20.2) (2026-08-28)
+
+
+### Bug Fixes
+
+* **agent:** recall search + memory_dir fallback + bersihkan dead llm_client ([f1f58b9](https://github.com/asepharyana/zesdex/commit/f1f58b9996f8eb58871d44fdd41c2d863874f253))
+
+## [1.20.1](https://github.com/asepharyana/zesdex/compare/v1.20.0...v1.20.1) (2026-08-28)
+
+
+### Bug Fixes
+
+* **agent:** subagent patuhi tool-calling contract + truncation char-safe ([e982cbe](https://github.com/asepharyana/zesdex/commit/e982cbeb041baea9cd500e2a29862a7eca9e6e17))
+
 # [1.20.0](https://github.com/asepharyana/zesdex/compare/v1.19.6...v1.20.0) (2026-08-28)
 
 

Cargo.lock

@@ -4862,7 +4862,7 @@ dependencies = [
 
 [[package]]
 name = "zesdex-api"
-version = "1.19.5"
+version = "1.20.2"
 dependencies = [
  "anyhow",
  "argon2",
@@ -4885,7 +4885,7 @@ dependencies = [
 
 [[package]]
 name = "zesdex-application"
-version = "1.19.5"
+version = "1.20.2"
 dependencies = [
  "anyhow",
  "base64",
@@ -4903,7 +4903,7 @@ dependencies = [
 
 [[package]]
 name = "zesdex-bootstrap"
-version = "1.19.5"
+version = "1.20.2"
 dependencies = [
  "anyhow",
  "chrono",
@@ -4920,7 +4920,7 @@ dependencies = [
 
 [[package]]
 name = "zesdex-daemon"
-version = "1.19.5"
+version = "1.20.2"
 dependencies = [
  "anyhow",
  "base64",
@@ -4944,7 +4944,7 @@ dependencies = [
 
 [[package]]
 name = "zesdex-domain"
-version = "1.19.5"
+version = "1.20.2"
 dependencies = [
  "anyhow",
  "base64",
@@ -4960,7 +4960,7 @@ dependencies = [
 
 [[package]]
 name = "zesdex-gateway"
-version = "1.19.5"
+version = "1.20.2"
 dependencies = [
  "anyhow",
  "axum",
@@ -4987,7 +4987,7 @@ dependencies = [
 
 [[package]]
 name = "zesdex-grpc"
-version = "1.19.5"
+version = "1.20.2"
 dependencies = [
  "anyhow",
  "axum",
@@ -5004,7 +5004,7 @@ dependencies = [
 
 [[package]]
 name = "zesdex-infrastructure"
-version = "1.19.5"
+version = "1.20.2"
 dependencies = [
  "anyhow",
  "argon2",
@@ -5052,7 +5052,7 @@ dependencies = [
 
 [[package]]
 name = "zesdex-tui"
-version = "1.19.5"
+version = "1.20.2"
 dependencies = [
  "anyhow",
  "base64",
@@ -5078,7 +5078,7 @@ dependencies = [
 
 [[package]]
 name = "zesdex-web"
-version = "1.19.5"
+version = "1.20.2"
 dependencies = [
  "anyhow",
  "axum",
@@ -5098,7 +5098,7 @@ dependencies = [
 
 [[package]]
 name = "zesdex-ws"
-version = "1.19.5"
+version = "1.20.2"
 dependencies = [
  "anyhow",
  "axum",

Cargo.toml

@@ -15,7 +15,7 @@ members = [
 ]
 
 [workspace.package]
-version = "1.20.0"
+version = "1.21.1"
 edition = "2021"
 authors = ["asepharyana <superaseph@gmail.com>"]
 

apps/infrastructure/src/subagent/auto/engine.rs

@@ -130,7 +130,7 @@ pub fn spawn_background_review(
             );
             format!(
                 "{}...\n[diff truncated at {} characters]",
-                &diff[..MAX_DIFF_CHARS],
+                crate::utils::truncate_chars(&diff, MAX_DIFF_CHARS),
                 MAX_DIFF_CHARS
             )
         } else {

apps/infrastructure/src/subagent/engine.rs

@@ -220,7 +220,7 @@ pub async fn run_agent(
             .await?;
 
         let content = response_msg.content.clone().unwrap_or_default();
-        let tool_calls = response_msg.tool_calls.unwrap_or_default();
+        let tool_calls = response_msg.tool_calls.clone().unwrap_or_default();
 
         // If no tool calls, we're done — return content
         if tool_calls.is_empty() {
@@ -229,6 +229,12 @@ pub async fn run_agent(
             return Ok(content);
         }
 
+        // Push the assistant message (with its tool_calls) BEFORE executing
+        // so the tool-calling contract is honoured: tool results reference
+        // the calls declared in the preceding assistant message. Without
+        // this, the history is malformed (`[...tool, tool, assistant]`).
+        messages.push(response_msg);
+
         // Execute tool calls — read-only batches run concurrently (bounded,
         // order preserved); any mutating tool forces the safe sequential path.
         let results = execute_tool_batch(&tools, &tool_ctx, &tool_calls);
@@ -266,11 +272,6 @@ pub async fn run_agent(
 
             messages.push(ChatMessage::tool(id, truncate_tool_output(result)));
         }
-
-        // Add assistant response if there was text content
-        if !content.is_empty() {
-            messages.push(ChatMessage::assistant(Some(content)));
-        }
     }
 
     info!("Subagent reached iteration limit ({MAX_ITERATIONS})");

apps/infrastructure/src/tools/context.rs

@@ -66,6 +66,14 @@ impl ToolCtxBuilder {
         self.session_dir = v;
         self
     }
+    pub fn memory_dir(mut self, v: PathBuf) -> Self {
+        self.memory_dir = v;
+        self
+    }
+    pub fn worktrees_dir(mut self, v: PathBuf) -> Self {
+        self.worktrees_dir = v;
+        self
+    }
     pub fn workspaces(mut self, v: Vec<PathBuf>) -> Self {
         self.workspaces = v;
         self

apps/infrastructure/src/tools/memory/forget.rs

@@ -43,7 +43,8 @@ impl Tool for Forget {
         let name = crate::tools::arg_str(args, "name")?;
         info!(name, "forget invoked");
         let repo = crate::persistence::cms::memory_repo::MarkdownMemoryRepository::new();
-        repo.delete(&ctx.memory_dir, &name)?;
+        let memory_dir = crate::tools::memory::resolve_memory_dir(&ctx.memory_dir);
+        repo.delete(&memory_dir, &name)?;
         info!(name, "memory deleted");
         Ok(format!("Memory '{}' deleted", name))
     }

apps/infrastructure/src/tools/memory/mod.rs

@@ -1,5 +1,21 @@
 //! Memory management tools — remember, recall, forget.
 
+use std::path::PathBuf;
+
 pub mod forget;
 pub mod recall;
 pub mod remember;
+
+/// Resolve the directory the memory tools should read/write.
+///
+/// Prefer an explicitly-configured `ToolCtx.memory_dir`. If that is empty
+/// (a `ToolCtx` is often built without setting `memory_dir`), fall back to
+/// the canonical persistent memory location from `Store` so memories are not
+/// silently written into the current working directory.
+pub fn resolve_memory_dir(ctx_memory_dir: &std::path::Path) -> PathBuf {
+    if ctx_memory_dir.as_os_str().is_empty() {
+        zesdex_domain::core::Store::new().memory_dir
+    } else {
+        ctx_memory_dir.to_path_buf()
+    }
+}

apps/infrastructure/src/tools/memory/recall.rs

@@ -45,16 +45,47 @@ impl Tool for Recall {
     #[instrument(skip(self, ctx, args))]
     fn run(&self, ctx: &ToolCtx, args: &Value) -> Result<String> {
         let repo = crate::persistence::cms::memory_repo::MarkdownMemoryRepository::new();
+        let memory_dir = crate::tools::memory::resolve_memory_dir(&ctx.memory_dir);
 
         let specific_name = args.get("name").and_then(|v| v.as_str());
+        let search = args.get("search").and_then(|v| v.as_str());
 
         if let Some(name) = specific_name {
             info!(name, "recall loading specific memory");
-            let memory = repo.load(&ctx.memory_dir, name)?;
-            Ok(serde_json::to_string_pretty(&memory)?)
-        } else {
+            let memory = repo.load(&memory_dir, name)?;
+            return Ok(serde_json::to_string_pretty(&memory)?);
+        }
+
+        if let Some(query) = search {
+            let query = query.trim().to_lowercase();
+            info!(search = %query, "recall searching memories");
+            if query.is_empty() {
+                return Ok("Search query is empty".to_string());
+            }
+            let names = repo.list(&memory_dir)?;
+            let mut matches: Vec<String> = Vec::new();
+            for name in &names {
+                // Load each memory and match against name/description/content.
+                if let Ok(m) = repo.load(&memory_dir, name) {
+                    let haystack =
+                        format!("{} {} {}", m.name, m.description, m.content).to_lowercase();
+                    if haystack.contains(&query) {
+                        matches.push(m.name);
+                    }
+                }
+            }
+            if matches.is_empty() {
+                return Ok(format!("No memories match '{query}'"));
+            }
+            return Ok(format!(
+                "Memories matching '{query}' ({}):\n{}",
+                matches.len(),
+                matches.join("\n")
+            ));
+        }
+
         info!("recall listing all memories");
-            let names = repo.list(&ctx.memory_dir)?;
+        let names = repo.list(&memory_dir)?;
         if names.is_empty() {
             info!("no memories found");
             return Ok("No memories saved yet".to_string());
@@ -62,4 +93,84 @@ impl Tool for Recall {
         Ok(format!("Available memories:\n{}", names.join("\n")))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::tools::ToolCtxBuilder;
+    use zesdex_domain::cms::MemoryRepository;
+
+    fn save_mem(name: &str, description: &str, content: &str, dir: &std::path::Path) {
+        let repo = crate::persistence::cms::memory_repo::MarkdownMemoryRepository::new();
+        let memory = zesdex_domain::cms::Memory {
+            name: name.to_string(),
+            description: description.to_string(),
+            content: content.to_string(),
+            kind: "reference".to_string(),
+            created_at: 0,
+            updated_at: 0,
+            outcome: None,
+            lifecycle: "active".to_string(),
+            scope: None,
+            before_snippet: None,
+            after_snippet: None,
+            provenances: Vec::new(),
+        };
+        repo.save(dir, &memory).unwrap();
+    }
+
+    #[test]
+    fn search_filters_memories_by_keyword() {
+        let dir = std::env::temp_dir().join(format!("zdx-mem-test-{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&dir).unwrap();
+        save_mem(
+            "rust-concurrency",
+            "tokio spawn patterns",
+            "how to use async tasks",
+            &dir,
+        );
+        save_mem(
+            "docker-deploy",
+            "deploy via compose",
+            "container orchestration",
+            &dir,
+        );
+
+        let tool_ctx = ToolCtxBuilder::default().memory_dir(dir.clone()).build();
+        let args = serde_json::json!({ "search": "tokio" });
+
+        let out = Recall.run(&tool_ctx, &args).unwrap();
+        assert!(
+            out.contains("rust-concurrency"),
+            "should match rust-concurrency, got: {out}"
+        );
+        assert!(
+            !out.contains("docker-deploy"),
+            "docker-deploy should not match tokio"
+        );
+
+        // A query with no match reports so.
+        let no_match = Recall
+            .run(&tool_ctx, &serde_json::json!({ "search": "zzzznope" }))
+            .unwrap();
+        assert!(no_match.contains("No memories match"), "{no_match}");
+
+        std::fs::remove_dir_all(&dir).ok();
+    }
+
+    #[test]
+    fn resolve_memory_dir_falls_back_to_store_when_empty() {
+        // An empty ToolCtx.memory_dir is resolved to the canonical Store path.
+        let resolved = crate::tools::memory::resolve_memory_dir(std::path::Path::new(""));
+        assert!(!resolved.as_os_str().is_empty());
+        assert!(
+            resolved.ends_with("memory"),
+            "expected memory dir, got {resolved:?}"
+        );
+
+        // An explicit memory_dir is preserved.
+        let explicit =
+            crate::tools::memory::resolve_memory_dir(std::path::Path::new("/tmp/custom-memory"));
+        assert_eq!(explicit, std::path::Path::new("/tmp/custom-memory"));
+    }
 }

apps/infrastructure/src/tools/memory/remember.rs

@@ -81,7 +81,8 @@ impl Tool for Remember {
         };
 
         let repo = crate::persistence::cms::memory_repo::MarkdownMemoryRepository::new();
-        repo.save(&ctx.memory_dir, &memory)?;
+        let memory_dir = crate::tools::memory::resolve_memory_dir(&ctx.memory_dir);
+        repo.save(&memory_dir, &memory)?;
 
         info!(name, "memory saved");
         Ok(format!("Memory '{}' saved", name))

apps/infrastructure/src/tools/semantic_search.rs

@@ -270,6 +270,17 @@ impl SymbolIndex {
         self.symbols.is_empty()
     }
 
+    /// Returns true when the cached index must be rebuilt for the given
+    /// workspace — either because nothing has been indexed yet, or because the
+    /// requested workspace differs from the one the index was built for.
+    ///
+    /// Without this, searching a *different* workspace after the first one
+    /// silently returns stale symbols from the previously indexed repo
+    /// (a misleading result for a coding agent).
+    pub fn needs_rebuild(&self, workspace: &str) -> bool {
+        self.is_empty() || self.workspace_path.as_deref() != Some(workspace)
+    }
+
     pub fn len(&self) -> usize {
         self.symbols.len()
     }
@@ -1255,7 +1266,7 @@ impl Tool for SemanticSearch {
             .map_err(|e| anyhow::anyhow!("index lock failed: {e}"))?;
         let index = guard.get_or_insert_with(SymbolIndex::new);
 
-        if rebuild || index.is_empty() {
+        if rebuild || index.needs_rebuild(&workspace) {
             let count = index.rebuild(&workspace)?;
             debug!(symbol_count = count, "symbol index rebuilt");
         }
@@ -1502,7 +1513,7 @@ impl Tool for ListSymbols {
             .map_err(|e| anyhow::anyhow!("index lock failed: {e}"))?;
         let index = guard.get_or_insert_with(SymbolIndex::new);
 
-        if rebuild || index.is_empty() {
+        if rebuild || index.needs_rebuild(&workspace) {
             let count = index.rebuild(&workspace)?;
             info!(symbol_count = count, "symbol index rebuilt for list");
         }
@@ -1746,4 +1757,38 @@ mod tests {
         let index = SymbolIndex::new();
         assert!(index.search("anything", 10).is_empty());
     }
+
+    #[test]
+    fn test_needs_rebuild_workspace_aware() {
+        let ws_a = std::env::temp_dir().join(format!("ws_a_{}", uuid::Uuid::new_v4()));
+        let ws_b = std::env::temp_dir().join(format!("ws_b_{}", uuid::Uuid::new_v4()));
+        std::fs::create_dir_all(&ws_a).unwrap();
+        std::fs::create_dir_all(&ws_b).unwrap();
+        std::fs::write(ws_a.join("a.rs"), "pub fn fn_in_a() {}\n").unwrap();
+        std::fs::write(ws_b.join("b.rs"), "pub fn fn_in_b() {}\n").unwrap();
+
+        let mut index = SymbolIndex::new();
+        let a = ws_a.to_string_lossy().to_string();
+        let b = ws_b.to_string_lossy().to_string();
+
+        // Fresh index: needs rebuild for any workspace.
+        assert!(index.needs_rebuild(&a));
+
+        // After rebuilding A, searching A needs no rebuild...
+        index.rebuild(&a).unwrap();
+        assert!(!index.needs_rebuild(&a));
+        // ...but searching B DOES (stale index otherwise).
+        assert!(
+            index.needs_rebuild(&b),
+            "workspace switch must trigger rebuild"
+        );
+
+        // Rebuilding B flips the cached workspace.
+        index.rebuild(&b).unwrap();
+        assert!(!index.needs_rebuild(&b));
+        assert!(index.needs_rebuild(&a));
+
+        std::fs::remove_dir_all(&ws_a).ok();
+        std::fs::remove_dir_all(&ws_b).ok();
+    }
 }

apps/infrastructure/src/tools/workflow.rs

@@ -9,7 +9,6 @@ use anyhow::Result;
 use serde_json::{json, Value};
 use tracing::{debug, info, instrument, warn};
 
-use crate::llm::provider::LlmClient;
 use crate::tools::{arg_str, Tool, ToolCtx};
 use crate::workflow::engine::execution::execute_workflow;
 use crate::workflow::hive_mind::cycle::execute_cycle;
@@ -60,14 +59,8 @@ impl Tool for WorkflowRun {
             phase_names.join(", ")
         );
 
-        let llm_client = LlmClient::new(
-            crate::llm::provider::DEFAULT_API_KEY.to_string(),
-            zesdex_domain::agent::defaults::DEFAULT_MODEL.to_string(),
-            None,
-        );
         let rt = crate::runtime::runtime();
-        let result: Vec<String> =
-            rt.block_on(async { execute_workflow(&script, ctx, &llm_client).await })?;
+        let result: Vec<String> = rt.block_on(async { execute_workflow(&script, ctx).await })?;
 
         info!(phase_count = result.len(), "Workflow completed");
         Ok(format!(

apps/infrastructure/src/utils.rs

@@ -275,7 +275,7 @@ pub fn build_rich_context(root: &Path) -> String {
         let p = root.join(file);
         if let Ok(content) = std::fs::read_to_string(&p) {
             let snippet = if content.len() > 1500 {
-                format!("{}\n... (truncated)", &content[..1500])
+                format!("{}\n... (truncated)", truncate_chars(&content, 1500))
             } else {
                 content
             };
@@ -301,7 +301,7 @@ pub fn build_rich_context(root: &Path) -> String {
     let readme_path = root.join("README.md");
     if let Ok(content) = std::fs::read_to_string(&readme_path) {
         let snippet = if content.len() > 1000 {
-            format!("{}\n... (truncated)", &content[..1000])
+            format!("{}\n... (truncated)", truncate_chars(&content, 1000))
         } else {
             content
         };
@@ -348,3 +348,53 @@ pub fn build_rich_context(root: &Path) -> String {
 
     ctx.trim_end().to_string()
 }
+
+/// Truncate a string to at most `max_chars` **characters**, never cutting a
+/// multi-byte UTF-8 code point in half.
+///
+/// `&s[..n]` with `n` a raw byte index panics when `n` lands inside a
+/// multi-byte character (e.g. an emoji, `→`, or CJK in a README/diff). This
+/// helper slices on character boundaries so content is safely capped at a
+/// byte budget while remaining valid UTF-8.
+pub fn truncate_chars(s: &str, max_chars: usize) -> String {
+    if s.chars().count() <= max_chars {
+        return s.to_string();
+    }
+    s.chars().take(max_chars).collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn truncate_chars_leaves_short_strings_unchanged() {
+        assert_eq!(truncate_chars("short", 100), "short");
+        assert_eq!(truncate_chars("", 5), "");
+    }
+
+    #[test]
+    fn truncate_chars_cuts_to_max_chars() {
+        assert_eq!(truncate_chars("hello world", 5), "hello");
+    }
+
+    #[test]
+    fn truncate_chars_never_splits_multibyte_utf8() {
+        // 4 chars each: '→' is 3 bytes. Byte-slicing at 5 would panic; char
+        // slicing must not.
+        let s = "a→b→c→d";
+        let t = truncate_chars(s, 5);
+        assert_eq!(t, "a→b→c");
+        assert!(t.chars().count() <= 5);
+        // No replacement char must appear (valid UTF-8 preserved).
+        assert!(!t.contains('\u{FFFD}'));
+    }
+
+    #[test]
+    fn truncate_chars_handles_emoji() {
+        let s = "🚀🚀🚀🚀";
+        let t = truncate_chars(s, 2);
+        assert_eq!(t, "🚀🚀");
+        assert!(t.chars().count() == 2);
+    }
+}

apps/infrastructure/src/workflow/engine/execution.rs

@@ -3,7 +3,6 @@
 use anyhow::Result;
 use tracing::{info, instrument};
 
-use crate::llm::provider::LlmClient;
 use crate::tools::ToolCtx;
 use crate::workflow::engine::primitives::execute_primitive;
 use zesdex_domain::workflow::WorkflowScript;
@@ -11,12 +10,8 @@ use zesdex_domain::workflow::WorkflowScript;
 /// Execute each phase of a workflow script sequentially.
 ///
 /// Flow: for each phase → execute_primitive → collect result.
-#[instrument(skip(tool_ctx, _llm_client))]
-pub async fn execute_workflow(
-    script: &WorkflowScript,
-    tool_ctx: &ToolCtx,
-    _llm_client: &LlmClient,
-) -> Result<Vec<String>> {
+#[instrument(skip(tool_ctx))]
+pub async fn execute_workflow(script: &WorkflowScript, tool_ctx: &ToolCtx) -> Result<Vec<String>> {
     info!(
         "Executing workflow: {} ({} phases)",
         script.name,

apps/infrastructure/src/workflow/hive_mind/synthesis.rs

@@ -1,28 +1,128 @@
 //! Consensus synthesis — reconciles multiple node outputs into one assessment.
+//!
+//! Flow: load settings → resolve LLM credentials → ask the model to distill the
+//! node outputs into a single consensus (conflicts, agreements, key findings)
+//! → return the synthesized text. If the LLM call fails for any reason, we
+//! degrade gracefully to a concatenation-based summary so consensus synthesis
+//! never breaks the surrounding hive-mind cycle (mirrors the isolated-errors
+//! philosophy used for the nodes themselves).
 
 use anyhow::Result;
-use tracing::info;
+use tracing::{info, warn};
 
-use crate::tools::ToolCtx;
+use zesdex_domain::cms::{AppConfigRepository, SettingsRepository};
+use zesdex_domain::core::message::ChatMessage;
+use zesdex_domain::core::Store;
 use zesdex_domain::workflow::NodeOutput;
 
-/// Synthesize a consensus from all node outputs.
+use crate::persistence::{JsonAppConfigRepository, JsonSettingsRepository};
+use crate::tools::ToolCtx;
+
+/// Maximum characters of node output to feed into the synthesis prompt per node.
+/// Keeps the prompt bounded so a huge/talkative node cannot blow up the request.
+const MAX_NODE_OUTPUT_CHARS: usize = 4000;
+
+/// Synthesize a consensus from all node outputs using the LLM.
 ///
-/// Flow: combine node outputs → return consensus text.
-/// Uses simple concatenation-based synthesis (avoids LLM call dependency).
+/// Flow: combine node outputs → ask the model to reconcile them into a single
+/// consensus → return the synthesized text. Falls back to a plain
+/// concatenation summary if the LLM is unreachable or the call fails.
 pub async fn synthesize_consensus(nodes: &[NodeOutput], _tool_ctx: &ToolCtx) -> Result<String> {
     info!("Synthesizing consensus from {} nodes", nodes.len());
 
-    let mut combined = String::new();
-    for node in nodes {
-        combined.push_str(&format!(
-            "\n## {} — {}\n\n{}\n",
-            node.id, node.directive, node.output
+    let combined = build_combined_body(nodes);
+
+    // 1. Resolve LLM credentials (same source of truth as execute_cycle).
+    let store = Store::new();
+    let settings = JsonSettingsRepository::new()
+        .load(&store.base_dir)
+        .unwrap_or_default();
+    let app_config = JsonAppConfigRepository::new()
+        .load(&store.base_dir)
+        .unwrap_or_default();
+
+    let (provider, model) =
+        crate::subagent::provider::resolve_subagent_provider(&settings, &app_config);
+    let base_url = app_config
+        .providers
+        .get(&provider)
+        .map(|p| p.api_base.clone())
+        .unwrap_or_else(|| zesdex_domain::agent::defaults::DEFAULT_API_BASE.to_string());
+    let api_key = crate::llm::provider::resolve_api_key(&settings, &app_config);
+
+    let client = crate::llm::provider::LlmClient::new(api_key, model, Some(base_url));
+
+    // 2. Build the synthesis prompt.
+    let system_msg = ChatMessage::system(
+        "You are a consensus synthesizer for a multi-agent hive mind. \
+         Several independent nodes analysed a problem and produced the outputs \
+         below. Distill them into ONE coherent consensus report with these \
+         sections:\n\
+         - AGREEMENTS: points multiple nodes converge on.\n\
+         - CONFLICTS: contradictory conclusions, with which node(s) support each side.\n\
+         - KEY FINDINGS: the most important, actionable takeaways.\n\
+         - RECOMMENDATION: a single recommended next action, or 'no clear consensus' \
+         if the outputs are too divergent.\n\
+         Be concise and factual. If a node errored, note it and ignore its content.\n\
+         Do not invent facts not present in the node outputs.",
+    );
+    let user_msg = ChatMessage::user(format!(
+        "Consolidate these {} node outputs into a single consensus:\n\n{}",
+        nodes.len(),
+        combined
     ));
+
+    // 3. Call the model and gracefully degrade on failure.
+    match call_consensus(&client, &[system_msg, user_msg]).await {
+        Ok(text) => {
+            let trimmed = text.trim();
+            if trimmed.is_empty() {
+                warn!("consensus LLM returned empty output; falling back to concat summary");
+                Ok(concat_summary(nodes))
+            } else {
+                Ok(format!(
+                    "# Consensus Synthesis\n\n\
+                     Nodes synthesized: {}\n\n{}",
+                    nodes.len(),
+                    trimmed
+                ))
+            }
+        }
+        Err(e) => {
+            warn!(error = %e, "consensus LLM call failed; falling back to concat summary");
+            Ok(concat_summary(nodes))
+        }
+    }
 }
 
-    Ok(format!(
-        "# Consensus Synthesis\n\
+/// Run the LLM consensus call and return the assistant text.
+async fn call_consensus(
+    client: &crate::llm::provider::LlmClient,
+    messages: &[ChatMessage],
+) -> Result<String> {
+    use zesdex_application::ports::ProviderService;
+    let (msg, _) = client.chat(messages, None, Some(1024), Some(0.3)).await?;
+    Ok(msg.content.unwrap_or_default())
+}
+
+/// Build the concatenated node-output body for the prompt.
+fn build_combined_body(nodes: &[NodeOutput]) -> String {
+    let mut combined = String::new();
+    for node in nodes {
+        let output = crate::utils::truncate_chars(&node.output, MAX_NODE_OUTPUT_CHARS);
+        combined.push_str(&format!(
+            "\n## {} — {}\n{}\n",
+            node.id, node.directive, output
+        ));
+    }
+    combined
+}
+
+/// Fallback: a plain concatenation summary (the behaviour of the original stub).
+fn concat_summary(nodes: &[NodeOutput]) -> String {
+    let combined = build_combined_body(nodes);
+    format!(
+        "# Consensus Synthesis\n\n\
          Nodes synthesized: {}\n\n\
          ## Summary\n\
          The following node outputs were collected:\n\
@@ -31,5 +131,47 @@ pub async fn synthesize_consensus(nodes: &[NodeOutput], _tool_ctx: &ToolCtx) ->
          Review the individual node outputs above for detailed findings.",
         nodes.len(),
         combined
-    ))
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use zesdex_domain::workflow::NodeOutput;
+
+    fn node(id: &str, output: &str) -> NodeOutput {
+        NodeOutput {
+            id: id.to_string(),
+            directive: "directive".to_string(),
+            output: output.to_string(),
+        }
+    }
+
+    #[test]
+    fn build_combined_body_truncates_oversized_output() {
+        let long = "é".repeat(MAX_NODE_OUTPUT_CHARS + 500);
+        let body = build_combined_body(&[node("n1", &long)]);
+        // Must contain the header and a char-truncated (<= cap) payload without
+        // panicking on a multi-byte boundary.
+        assert!(body.contains("## n1"));
+        // Header "## n1 — directive\n" ~= 20 chars, so char count stays just above cap.
+        let char_count = body.chars().count();
+        assert!(
+            char_count <= MAX_NODE_OUTPUT_CHARS + 50,
+            "expected body near {MAX_NODE_OUTPUT_CHARS} chars, got {char_count}"
+        );
+        assert!(
+            char_count > 1000,
+            "expected a many-node output, got small: {char_count}"
+        );
+    }
+
+    #[test]
+    fn concat_summary_includes_all_node_ids() {
+        let nodes = vec![node("node-a", "a out"), node("node-b", "b out")];
+        let summary = concat_summary(&nodes);
+        assert!(summary.contains("node-a"));
+        assert!(summary.contains("node-b"));
+        assert!(summary.contains("Nodes synthesized: 2"));
+    }
 }