v0.56.0 — Eliminate post-response hang: run learn loop and episode extraction asynchronously

After the agent delivers its response, the process was making blocking
LLM calls for skill learning (ExtractSkillsFromConversation +
GenerateSkillWithLLM) and episode extraction (OnSessionEnd), causing
a 2-5 second hang before the process terminated.

Fix: wrap all four post-response LLM operations in goroutines so the
process can exit immediately after delivering the response. These are
best-effort operations — skill auto-save and episode summarization
still happen, but they no longer block termination.

Locations changed:
- cmd/odek/main.go (run): learn loop + session end → goroutines
- cmd/odek/main.go (continueCmd): session end → goroutine
- cmd/odek/repl.go: session end → goroutine
- cmd/odek/main_test.go: sync learn loop tests to async behavior

Author: jkyberneees

cmd/odek/main.go

@@ -1071,23 +1071,29 @@ func run(args []string) error {
 	}
 
 	// ── Learn loop: run self-improvement heuristics ──
+	// Run asynchronously so the process can exit immediately after
+	// the response is delivered. Skill learning is best-effort
+	// post-processing that should not block termination.
 	if resolved.Skills.Learn && sm != nil {
-		// Create LLM client for skill enhancement
-		skillsLLM := llm.New(resolved.BaseURL, resolved.APIKey, resolved.Model, "", 30*time.Second)
-		runLearnLoop(allMessages, f.Task, sm, skillsLLM, resolved.Skills)
+		go func() {
+			skillsLLM := llm.New(resolved.BaseURL, resolved.APIKey, resolved.Model, "", 30*time.Second)
+			runLearnLoop(allMessages, f.Task, sm, skillsLLM, resolved.Skills)
+		}()
 	}
 
 	// ── Session end — extract episode if enough turns ──
+	// Run asynchronously so episode extraction does not delay process exit.
 	if mm := agent.Memory(); mm != nil && f.Session != nil && *f.Session {
-		// We need the session for OnSessionEnd. Re-create it from the stored data.
-		sess, err := session.NewStore()
-		if err == nil {
-			latest, err := sess.Latest()
+		go func() {
+			sess, err := session.NewStore()
 			if err == nil {
-				msgStrs := makeSessionMessageStrings(latest)
-				mm.OnSessionEnd(latest.ID, latest.Turns, msgStrs)
+				latest, err := sess.Latest()
+				if err == nil {
+					msgStrs := makeSessionMessageStrings(latest)
+					mm.OnSessionEnd(latest.ID, latest.Turns, msgStrs)
+				}
 			}
-		}
+		}()
 	}
 
 	// ── Delivery: send result to default channel ──
@@ -2017,9 +2023,12 @@ func continueCmd(args []string) error {
 	fmt.Fprintf(os.Stderr, "odek: session %s saved (%d turns)\n", sess.ID, sess.Turns+1)
 
 	// ── Session end — extract episode ──
+	// Run asynchronously so episode extraction does not delay process exit.
 	if mm := agent.Memory(); mm != nil {
-		msgStrs := makeSessionMessageStrings(sess)
-		mm.OnSessionEnd(sess.ID, sess.Turns+1, msgStrs)
+		go func() {
+			msgStrs := makeSessionMessageStrings(sess)
+			mm.OnSessionEnd(sess.ID, sess.Turns+1, msgStrs)
+		}()
 	}
 
 	return nil

cmd/odek/main_test.go

@@ -12,6 +12,7 @@ import (
 	"path/filepath"
 	"strings"
 	"testing"
+	"time"
 
 	"github.com/BackendStack21/odek"
 	"github.com/BackendStack21/odek/internal/config"
@@ -1394,6 +1395,10 @@ func TestRunLearn_MultiStepProcedure(t *testing.T) {
 	defer func() { os.Stderr = oldStderr }()
 
 	err := run([]string{"--learn", "--base-url", server.URL, "multi step task"})
+	// Learn loop now runs asynchronously; give it a moment to complete.
+	// With llm_learn=false the heuristics are instant, but we still
+	// need to let the goroutine write to stderr before closing the pipe.
+	time.Sleep(200 * time.Millisecond)
 	errW.Close()
 	errOutput, _ := io.ReadAll(errR)
 
@@ -1412,12 +1417,16 @@ func TestRunLearn_MultiStepProcedure(t *testing.T) {
 		t.Error("expected 'multi-step' heuristic in output")
 	}
 
-	// Skill file written to disk
+	// Skill file written to disk — poll since the goroutine may still be writing.
 	skillDir := filepath.Join(homeDir, ".odek", "skills", "procedure-echo")
 	skillFile := filepath.Join(skillDir, "SKILL.md")
-	if _, err := os.Stat(skillFile); os.IsNotExist(err) {
-		t.Errorf("expected skill file at %s", skillFile)
+	for i := 0; i < 10; i++ {
+		if _, err := os.Stat(skillFile); err == nil {
+			return // found
+		}
+		time.Sleep(50 * time.Millisecond)
 	}
+	t.Errorf("expected skill file at %s", skillFile)
 }
 
 // TestRunLearn_InteractiveReject verifies that when auto-save is disabled,
@@ -1459,6 +1468,8 @@ func TestRunLearn_InteractiveReject(t *testing.T) {
 	defer func() { os.Stderr = oldStderr }()
 
 	err := run([]string{"--learn", "--base-url", server.URL, "multi step task"})
+	// Learn loop runs asynchronously; give it a moment to write stderr.
+	time.Sleep(200 * time.Millisecond)
 	errW.Close()
 	errOutput, _ := io.ReadAll(errR)
 

cmd/odek/repl.go

@@ -270,14 +270,17 @@ func replCmd(args []string) error {
 		fmt.Fprintln(os.Stderr)
 	}
 
-	// Session end — extract episode if enough turns
+	// Session end — extract episode if enough turns.
+	// Run asynchronously so episode extraction does not delay process exit.
 	if mm := agent.Memory(); mm != nil {
-		messages := sess.GetMessages()
-		msgStrs := make([]string, 0, len(messages))
-		for _, m := range messages {
-			msgStrs = append(msgStrs, m.Role+": "+m.Content)
-		}
-		mm.OnSessionEnd(sess.ID, sess.Turns, msgStrs)
+		go func() {
+			messages := sess.GetMessages()
+			msgStrs := make([]string, 0, len(messages))
+			for _, m := range messages {
+				msgStrs = append(msgStrs, m.Role+": "+m.Content)
+			}
+			mm.OnSessionEnd(sess.ID, sess.Turns, msgStrs)
+		}()
 	}
 
 	return nil