feat(token): add refresh token verification to TokenService

feat(bootstrap): create temporary settings and config files to prevent data loss

refactor(edit_log): switch from Vec to VecDeque for efficient memory management

fix(gateway): ensure store directories are created before starting the API server

refactor(bgbash): implement a global singleton for BashControl

feat(auth): enhance session authentication middleware to use SessionRepository

fix(edit_log_repo): update to use VecDeque for in-memory edit log storage

fix(memory_repo): add newline escaping for frontmatter fields

fix(session_lock_repo): improve error handling for lock file operations

fix(bash_tools): prevent path traversal in job_id argument

refactor(delete): enforce empty directory deletion in file system tools

fix(edit): optimize string replacement to only replace the first occurrence

fix(git_cred): improve credential management with piped input to git commands

feat(git_operator): add safety filter to block destructive git operations

fix(shell): register background jobs in Bash control

feat(spawn): add access tier specification for pipeline stages

refactor(hive_mind): run directives concurrently for improved performance

fix(auth): update refresh token verification in the refresh handler

fix(chat): optimize LLM client usage based on model matching

fix(conversations): enhance message deletion to target specific indices

feat(api): add JWT authentication middleware for all API routes

fix(state): implement refresh token verification in JwtTokenService

fix(daemon): improve usage tracking with saturating addition

fix(tui): handle compacted messages in the TUI state management

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

@@ -1,9 +1,10 @@
 //! Hive-mind cycle execution — run one cycle of parallel nodes.
 //!
-//! Flow: load settings → resolve LLM credentials → for each directive,
-//! build a SubagentContext and call run_agent → collect NodeOutputs.
+//! Flow: load settings → resolve LLM credentials → run all directives in the
+//! cycle concurrently via try_join_all → collect Vec<NodeOutput>.
 
 use anyhow::Result;
+use futures_util::future::try_join_all;
 use tracing::info;
 
 use zesdex_domain::cms::{AppConfigRepository, SettingsRepository};
@@ -21,8 +22,9 @@ use crate::workflow::hive_mind::types::{CognitiveCycle, NodeOutput};
 /// Flow:
 ///   1. Load `Settings` and `AppConfig` from the store directory.
 ///   2. Resolve provider, model, base_url, and api_key.
-///   3. For each directive → build `SubagentContext` → `run_agent` (Full access).
-///   4. Collect `NodeOutput` results.
+///   3. Spawn all directives concurrently — each builds a `SubagentContext`
+///      and calls `run_agent` (Full access).
+///   4. `try_join_all` waits for all to complete, then collect `NodeOutput`s.
 pub async fn execute_cycle(
     cycle: &CognitiveCycle,
     tool_ctx: &ToolCtx,
@@ -52,25 +54,37 @@ pub async fn execute_cycle(
 
     let api_key = crate::llm::provider::resolve_api_key(&settings, &app_config);
 
-    let mut outputs = Vec::new();
-    for (i, directive) in cycle.directives.iter().enumerate() {
-        let ctx = SubagentContext::new(
-            directive.clone(),
-            tool_ctx.clone(),
-            "full".to_string(),
-            base_url.clone(),
-            api_key.clone(),
-            model.clone(),
-        );
+    let cycle_index = cycle.index;
 
-        let result = run_agent(ctx, directive, AccessTier::Full, tool_ctx.clone()).await?;
+    // Run all directives in this cycle concurrently.
+    let handles: Vec<_> = cycle
+        .directives
+        .iter()
+        .enumerate()
+        .map(|(i, directive)| {
+            let dir = directive.clone();
+            let ctx = SubagentContext::new(
+                dir.clone(),
+                tool_ctx.clone(),
+                "full".to_string(),
+                base_url.clone(),
+                api_key.clone(),
+                model.clone(),
+            );
+            let tc = tool_ctx.clone();
 
-        outputs.push(NodeOutput {
-            id: format!("Node-{}-{}", cycle.index, i),
-            directive: directive.clone(),
-            output: result,
-        });
-    }
+            async move {
+                let result = run_agent(ctx, &dir, AccessTier::Full, tc).await?;
+                Ok::<NodeOutput, anyhow::Error>(NodeOutput {
+                    id: format!("Node-{}-{}", cycle_index, i),
+                    directive: dir,
+                    output: result,
+                })
+            }
+        })
+        .collect();
 
-    Ok(outputs)
+    let results = try_join_all(handles).await?;
+
+    Ok(results)
 }