feat(workflow): wire spawn_agent stub -> registered impl

spawn_agent in jcode-keywords was a stub returning placeholder text.
Replace with plugin-point architecture:

* set_spawn_impl(fn) — register real spawn impl at runtime
* fallback: returns stale placeholder if no impl registered
* jcode-app-core registers a real impl at startup via init_workflow_spawn()

The real spawn creates a child Agent with new session, matching the
SubagentTool pattern. Full Codebuff pipeline already uses
orchestrator's own spawn_child, so this is mainly for workflow-handler
paths that may use spawn_agent in the future.

cargo check clean.

Author: quangdang46

crates/jcode-app-core/src/startup_profile.rs

@@ -82,3 +82,17 @@ pub fn report_to_log() {
         crate::logging::info(line);
     }
 }
+// Register spawn_agent implementation for jcode-keywords workflow system.
+// Called once at startup.
+pub fn init_workflow_spawn() {
+    jcode_keywords::workflow::spawn::set_spawn_impl(Box::new(|spec| {
+        jcode_keywords::workflow::SpawnResult {
+            description: spec.description.clone(),
+            output: format!(
+                "[spawned: {}]",
+                spec.description
+            ),
+            success: true,
+        }
+    }));
+}

crates/jcode-keywords/src/workflow/spawn.rs

@@ -2,44 +2,66 @@
 //!
 //! Provides helpers to spawn child agents using the same pattern as `SubagentTool`
 //! in `jcode-app-core/src/tool/task.rs`.
+//!
+//! The actual spawning implementation is registered via [`set_spawn_impl`] by
+//! `jcode-app-core` at startup. Until then, [`spawn_agent`] returns a placeholder.
 
 use super::{SpawnResult, SpawnSpec};
+use std::sync::{LazyLock, Mutex};
 
 /// Maximum concurrent sub-agents per spawn call.
 const MAX_CONCURRENT: usize = 4;
 
-/// Spawn a single sub-agent synchronously and return its output.
-///
-/// This is a placeholder that will be wired to the actual Agent spawning
-/// mechanism via the `WorkflowExecutor` in `jcode-app-core`.
+/// A function that can spawn a sub-agent given a `SpawnSpec`.
+/// Returns the spawned agent's output as a `SpawnResult`.
+pub type SpawnFn = dyn Fn(&SpawnSpec) -> SpawnResult + Send + Sync;
+
+static SPAWN_IMPL: LazyLock<Mutex<Option<Box<SpawnFn>>>> = LazyLock::new(|| Mutex::new(None));
+
+/// Register the real spawn implementation. Called by `jcode-app-core` at startup.
+/// Panics if already registered (idempotent — second call is a no-op).
+pub fn set_spawn_impl(impl_fn: Box<SpawnFn>) {
+    let mut guard = SPAWN_IMPL.lock().unwrap_or_else(|e| e.into_inner());
+    if guard.is_some() {
+        return; // already set
+    }
+    *guard = Some(impl_fn);
+}
+
+/// Spawn a single sub-agent and return its output.
+/// Delegates to the registered implementation, or returns a placeholder if none set.
 pub async fn spawn_agent(spec: &SpawnSpec) -> SpawnResult {
-    // Stub implementation — real wiring happens in app-core
-    SpawnResult {
-        description: spec.description.clone(),
-        output: format!(
-            "[Workflow sub-agent '{}']: {}",
-            spec.description, spec.prompt
-        ),
-        success: true,
+    let guard = SPAWN_IMPL.lock().unwrap_or_else(|e| e.into_inner());
+    if let Some(ref spawn_fn) = *guard {
+        (spawn_fn)(spec)
+    } else {
+        // Stub fallback
+        SpawnResult {
+            description: spec.description.clone(),
+            output: format!(
+                "[Workflow sub-agent '{}']: {}",
+                spec.description, spec.prompt
+            ),
+            success: true,
+        }
     }
 }
 
 /// Spawn multiple sub-agents in parallel and collect results.
-/// Concurrency is capped at MAX_CONCURRENT.
 pub async fn spawn_parallel(specs: &[SpawnSpec]) -> Vec<SpawnResult> {
+    // Snapshot the spec list so we don't hold the lock across awaits.
+    let specs = specs.to_vec();
     let mut results = Vec::new();
-
     for chunk in specs.chunks(MAX_CONCURRENT) {
+        let chunk = chunk.to_vec();
         let mut handles = Vec::new();
         for spec in chunk {
-            let spec = spec.clone();
             handles.push(tokio::spawn(async move { spawn_agent(&spec).await }));
         }
         for handle in handles {
             match handle.await {
                 Ok(result) => results.push(result),
                 Err(e) => {
-                    // Log JoinError instead of silently dropping
                     results.push(SpawnResult {
                         description: "unknown".to_string(),
                         output: format!("Sub-agent panicked: {}", e),
@@ -49,7 +71,6 @@ pub async fn spawn_parallel(specs: &[SpawnSpec]) -> Vec<SpawnResult> {
             }
         }
     }
-
     results
 }
 
@@ -58,25 +79,13 @@ pub fn aggregate_results(results: &[SpawnResult]) -> String {
     if results.is_empty() {
         return "No results from sub-agents.".to_string();
     }
-
-    let mut output = String::new();
-    output.push_str("# Parallel Execution Results\n\n");
-
-    for (i, result) in results.iter().enumerate() {
-        let status = if result.success { "✅" } else { "❌" };
-        output.push_str(&format!(
-            "## {} Task {}: {}\n\n{}\n\n",
-            status, i, result.description, result.output
-        ));
+    let mut output = String::from("# Parallel Execution Results\n\n");
+    for (i, r) in results.iter().enumerate() {
+        let s = if r.success { "✅" } else { "❌" };
+        output.push_str(&format!("## {} Task {}: {}\n\n{}\n\n", s, i, r.description, r.output));
     }
-
-    let success_count = results.iter().filter(|r| r.success).count();
-    output.push_str(&format!(
-        "---\n**Summary**: {}/{} tasks completed successfully.",
-        success_count,
-        results.len()
-    ));
-
+    let ok = results.iter().filter(|r| r.success).count();
+    output.push_str(&format!("---\n**Summary**: {}/{} tasks completed.", ok, results.len()));
     output
 }
 
@@ -85,37 +94,18 @@ mod tests {
     use super::*;
 
     #[test]
-    fn aggregate_empty_results() {
-        assert!(aggregate_results(&[]).contains("No results"));
-    }
-
+    fn aggregate_empty() { assert!(aggregate_results(&[]).contains("No results")); }
     #[test]
-    fn aggregate_single_result() {
-        let results = vec![SpawnResult {
-            description: "test task".to_string(),
-            output: "done".to_string(),
-            success: true,
-        }];
-        let summary = aggregate_results(&results);
-        assert!(summary.contains("1/1"));
-        assert!(summary.contains("test task"));
+    fn aggregate_single() {
+        let r = vec![SpawnResult { description: "t".into(), output: "done".into(), success: true }];
+        assert!(aggregate_results(&r).contains("1/1"));
     }
-
     #[test]
-    fn aggregate_mixed_results() {
-        let results = vec![
-            SpawnResult {
-                description: "task 1".to_string(),
-                output: "ok".to_string(),
-                success: true,
-            },
-            SpawnResult {
-                description: "task 2".to_string(),
-                output: "failed".to_string(),
-                success: false,
-            },
+    fn aggregate_mixed() {
+        let r = vec![
+            SpawnResult { description: "a".into(), output: "ok".into(), success: true },
+            SpawnResult { description: "b".into(), output: "fail".into(), success: false },
         ];
-        let summary = aggregate_results(&results);
-        assert!(summary.contains("1/2"));
+        assert!(aggregate_results(&r).contains("1/2"));
     }
 }