fix: Sessions

Author: codefionn

cmd/scriptschnell/main.go

@@ -1002,13 +1002,39 @@ func runTUI(cfg *config.Config, providerMgr *provider.Manager, cliOptions *cli.O
 								return nil
 							}
 
-							sessionID := selectedItem.GetSessionID()
-							if sessionID == "" {
-								return fmt.Errorf("invalid session selected")
-							}
-
 							switch action {
+							case "save":
+								// Save current session
+								activeOrch := getActiveOrchestrator()
+								if activeOrch == nil {
+									return fmt.Errorf("no active session to save")
+								}
+
+								saveName := sessionMenu.GetSaveName()
+								if saveName == "" {
+									saveName = actor.GenerateSessionName("")
+								} else {
+									saveName = actor.GenerateSessionName(saveName)
+								}
+
+								// Generate session title if not already present
+								if err := activeOrch.GenerateSessionTitle(ctx); err != nil {
+									logger.Warn("session save: failed to generate title: %v", err)
+								}
+
+								currentSession := activeOrch.GetSession()
+								if err := actor.SaveSessionViaActor(ctx, storageRef, currentSession, saveName); err != nil {
+									return fmt.Errorf("failed to save session: %w", err)
+								}
+
+								model.AddSystemMessage(fmt.Sprintf("Session saved as '%s'", saveName))
+
 							case "load":
+								sessionID := selectedItem.GetSessionID()
+								if sessionID == "" {
+									return fmt.Errorf("invalid session selected")
+								}
+
 								// Load the session using actor
 								loadedSession, err := actor.LoadSessionViaActor(ctx, storageRef, cfg.WorkingDir, sessionID)
 								if err != nil {
@@ -1041,6 +1067,11 @@ func runTUI(cfg *config.Config, providerMgr *provider.Manager, cliOptions *cli.O
 								model.AddSystemMessage(fmt.Sprintf("Loaded session: %s", selectedItem.Title()))
 
 							case "delete":
+								sessionID := selectedItem.GetSessionID()
+								if sessionID == "" {
+									return fmt.Errorf("invalid session selected")
+								}
+
 								// Delete the session using actor
 								deleteMsg := actor.SessionStorageDeleteMsg{
 									WorkingDir:   cfg.WorkingDir,

internal/acp/agent.go

@@ -287,15 +287,35 @@ func (a *ScriptschnellAIAgent) handleClearCommand(session *statcodeSession) stri
 
 	logger.Debug("handleClearCommand[%s]: clearing session", session.sessionID)
 
+	// Auto-save the current session before clearing if it has messages
+	saved := false
+	currentSession := session.orchestrator.GetSession()
+	if currentSession != nil && len(currentSession.GetMessages()) > 0 {
+		if storageRef, exists := session.orchestrator.GetActor("session_storage"); exists {
+			// Generate session title (best-effort)
+			if err := session.orchestrator.GenerateSessionTitle(context.Background()); err != nil {
+				logger.Warn("handleClearCommand[%s]: failed to generate title: %v", session.sessionID, err)
+			}
+
+			name := actor.GenerateSessionName("")
+			if err := actor.SaveSessionViaActor(context.Background(), storageRef, currentSession, name); err != nil {
+				logger.Warn("handleClearCommand[%s]: failed to auto-save session: %v", session.sessionID, err)
+			} else {
+				logger.Info("handleClearCommand[%s]: auto-saved session %s as '%s'", session.sessionID, currentSession.ID, name)
+				saved = true
+			}
+		}
+	}
+
 	if err := session.orchestrator.ClearSession(); err != nil {
 		logger.Warn("handleClearCommand[%s]: failed to clear session: %v", session.sessionID, err)
 		return fmt.Sprintf("⚠️ Failed to clear session: %v", err)
 	}
 
-	response := "🧹 Conversation context and todos cleared.\n\n"
-	response += "Ready for a fresh start! What would you like to work on?\n"
-
-	return response
+	if saved {
+		return "🧹 Session saved and cleared.\n\nReady for a fresh start! What would you like to work on?\n"
+	}
+	return "🧹 Conversation context and todos cleared.\n\nReady for a fresh start! What would you like to work on?\n"
 }
 
 // handleContextCommand handles the /context command

internal/session/session.go

@@ -4,7 +4,6 @@ import (
 	"context"
 	"crypto/rand"
 	"encoding/hex"
-	"fmt"
 	"os"
 	"path/filepath"
 	"strings"
@@ -177,14 +176,9 @@ func createShellTempDir() string {
 	return dirPath
 }
 
-// GenerateID creates a random session ID (base32-ish hex, 12 chars).
+// GenerateID creates a human-friendly session ID (e.g. "bright-silver-falcon").
 func GenerateID() string {
-	var buf [6]byte
-	if _, err := rand.Read(buf[:]); err != nil {
-		timestamp := time.Now().UnixNano()
-		return fmt.Sprintf("sess-%d", timestamp)
-	}
-	return hex.EncodeToString(buf[:])
+	return GenerateWordID()
 }
 
 // AddMessage adds a message to the session

internal/session/storage.go

@@ -285,14 +285,15 @@ func (s *SessionStorage) SaveSession(session *Session, name string) error {
 	}
 
 	// Write to temporary file first (atomic write)
-	tempPath := s.getSessionPath(session.WorkingDir, storedID) + ".tmp"
-	logger.Debug("SaveSession: creating temp file: %s", tempPath)
-
-	file, err := os.Create(tempPath)
+	// Use os.CreateTemp to avoid races between concurrent saves (e.g. auto-save + manual save)
+	finalPath := s.getSessionPath(session.WorkingDir, storedID)
+	file, err := os.CreateTemp(workspaceDir, storedID+".gob.tmp.*")
 	if err != nil {
-		logger.Error("SaveSession: failed to create temp file %s: %v", tempPath, err)
+		logger.Error("SaveSession: failed to create temp file in %s: %v", workspaceDir, err)
 		return fmt.Errorf("failed to create temp file: %w", err)
 	}
+	tempPath := file.Name()
+	logger.Debug("SaveSession: created temp file: %s", tempPath)
 
 	// Encode with gob
 	logger.Debug("SaveSession: encoding session with gob")
@@ -308,7 +309,6 @@ func (s *SessionStorage) SaveSession(session *Session, name string) error {
 	file.Close()
 
 	// Atomic rename
-	finalPath := s.getSessionPath(session.WorkingDir, storedID)
 	logger.Debug("SaveSession: renaming %s to %s", tempPath, finalPath)
 
 	if err := os.Rename(tempPath, finalPath); err != nil {

internal/session/wordid.go

@@ -0,0 +1,69 @@
+package session
+
+import (
+	"crypto/rand"
+	"fmt"
+	"math/big"
+)
+
+var adjectives = []string{
+	"amber", "azure", "bold", "brave", "bright",
+	"calm", "clear", "cold", "cool", "coral",
+	"crisp", "dark", "dawn", "deep", "dry",
+	"dusk", "early", "east", "fair", "fast",
+	"firm", "flat", "fresh", "frost", "full",
+	"glad", "gold", "grand", "gray", "green",
+	"half", "high", "hot", "icy", "iron",
+	"keen", "kind", "late", "lean", "light",
+	"lime", "live", "long", "low", "mild",
+	"mint", "mist", "near", "neat", "next",
+	"north", "odd", "old", "opal", "open",
+	"pale", "peak", "pine", "pink", "plain",
+	"prime", "pure", "quiet", "rare", "raw",
+	"red", "rich", "ripe", "rose", "ruby",
+	"rust", "safe", "sage", "silk", "slim",
+	"slow", "soft", "south", "stark", "steel",
+	"still", "stone", "sun", "swift", "tall",
+	"teal", "thin", "true", "warm", "west",
+	"white", "wide", "wild", "wise", "young",
+}
+
+var nouns = []string{
+	"arch", "ash", "bay", "beam", "birch",
+	"bloom", "bolt", "brook", "cape", "cave",
+	"cedar", "cliff", "cloud", "coast", "cove",
+	"crane", "creek", "crest", "crow", "dale",
+	"dart", "dawn", "delta", "dove", "drift",
+	"dune", "dust", "elm", "ember", "fern",
+	"field", "finch", "flame", "flint", "fog",
+	"forge", "fox", "frost", "gale", "gate",
+	"glen", "grove", "hare", "hawk", "heath",
+	"hill", "hive", "hollow", "ivy", "jade",
+	"jay", "lake", "lark", "leaf", "ledge",
+	"lily", "loft", "maple", "marsh", "mesa",
+	"mist", "moss", "moth", "oak", "orbit",
+	"otter", "owl", "palm", "path", "peak",
+	"pine", "plum", "pond", "quail", "rain",
+	"raven", "reef", "ridge", "river", "rock",
+	"sage", "shore", "sky", "slope", "snow",
+	"spark", "spruce", "star", "stone", "storm",
+	"stream", "swift", "thorn", "tide", "trail",
+	"vale", "vine", "wave", "willow", "wolf",
+}
+
+// GenerateWordID generates a human-friendly ID in the form "adjective-adjective-noun".
+func GenerateWordID() string {
+	adj1 := pickRandom(adjectives)
+	adj2 := pickRandom(adjectives)
+	noun := pickRandom(nouns)
+	return fmt.Sprintf("%s-%s-%s", adj1, adj2, noun)
+}
+
+func pickRandom(list []string) string {
+	n, err := rand.Int(rand.Reader, big.NewInt(int64(len(list))))
+	if err != nil {
+		// Fallback: just use first element (should never happen)
+		return list[0]
+	}
+	return list[n.Int64()]
+}