fix(acp): resolve effective conversation cwd

Author: onutc

api/acp_bootstrap.go

@@ -21,6 +21,7 @@ import (
 type acpBootstrapResponse struct {
 	Conversation       *spritzv1.SpritzConversation    `json:"conversation"`
 	EffectiveSessionID string                          `json:"effectiveSessionId,omitempty"`
+	EffectiveCWD       string                          `json:"effectiveCwd,omitempty"`
 	BindingState       string                          `json:"bindingState,omitempty"`
 	Loaded             bool                            `json:"loaded,omitempty"`
 	Replaced           bool                            `json:"replaced,omitempty"`
@@ -417,10 +418,16 @@ func (s *server) bootstrapACPConversationBinding(ctx context.Context, conversati
 		return nil, err
 	}
 
-	return s.bootstrapACPConversationBindingWithClient(ctx, conversation, client, initResult)
+	return s.bootstrapACPConversationBindingWithClient(ctx, conversation, spritz, client, initResult)
 }
 
-func (s *server) bootstrapACPConversationBindingWithClient(ctx context.Context, conversation *spritzv1.SpritzConversation, client *acpBootstrapInstanceClient, initResult *acpBootstrapInitializeResult) (*acpBootstrapResponse, error) {
+func (s *server) bootstrapACPConversationBindingWithClient(
+	ctx context.Context,
+	conversation *spritzv1.SpritzConversation,
+	spritz *spritzv1.Spritz,
+	client *acpBootstrapInstanceClient,
+	initResult *acpBootstrapInitializeResult,
+) (*acpBootstrapResponse, error) {
 	if !initResult.AgentCapabilities.LoadSession {
 		err := errors.New("agent does not support session/load")
 		s.recordConversationBindingError(ctx, conversation.Namespace, conversation.Name, "", err)
@@ -429,6 +436,7 @@ func (s *server) bootstrapACPConversationBindingWithClient(ctx context.Context,
 
 	agentInfo := normalizeBootstrapAgentInfo(initResult)
 	capabilities := normalizeBootstrapCapabilities(initResult)
+	effectiveCWD := resolveConversationEffectiveCWD(spritz, conversation)
 	effectiveSessionID := strings.TrimSpace(conversation.Spec.SessionID)
 	previousSessionID := ""
 	bindingState := "active"
@@ -438,12 +446,12 @@ func (s *server) bootstrapACPConversationBindingWithClient(ctx context.Context,
 	var err error
 
 	if effectiveSessionID != "" {
-		replayMessageCount, err = client.loadSession(ctx, effectiveSessionID, normalizeConversationCWD(conversation.Spec.CWD))
+		replayMessageCount, err = client.loadSession(ctx, effectiveSessionID, effectiveCWD)
 		if err != nil {
 			var rpcErr *acpBootstrapRPCError
 			if errors.As(err, &rpcErr) && rpcErr.missingSession() {
 				previousSessionID = effectiveSessionID
-				effectiveSessionID, err = client.newSession(ctx, normalizeConversationCWD(conversation.Spec.CWD))
+				effectiveSessionID, err = client.newSession(ctx, effectiveCWD)
 				if err != nil {
 					s.recordConversationBindingError(ctx, conversation.Namespace, conversation.Name, previousSessionID, err)
 					return nil, err
@@ -458,7 +466,7 @@ func (s *server) bootstrapACPConversationBindingWithClient(ctx context.Context,
 			loaded = true
 		}
 	} else {
-		effectiveSessionID, err = client.newSession(ctx, normalizeConversationCWD(conversation.Spec.CWD))
+		effectiveSessionID, err = client.newSession(ctx, effectiveCWD)
 		if err != nil {
 			s.recordConversationBindingError(ctx, conversation.Namespace, conversation.Name, "", err)
 			return nil, err
@@ -473,11 +481,13 @@ func (s *server) bootstrapACPConversationBindingWithClient(ctx context.Context,
 
 	updatedConversation, err := s.updateConversationBinding(ctx, conversation.Namespace, conversation.Name, func(current *spritzv1.SpritzConversation) {
 		now := metav1.Now()
+		current.Spec.CWD = normalizeConversationOverrideCWD(spritz, current.Spec.CWD)
 		current.Spec.SessionID = effectiveSessionID
 		current.Spec.AgentInfo = agentInfo
 		current.Spec.Capabilities = capabilities
 		current.Status.BoundSessionID = effectiveSessionID
 		current.Status.BindingState = bindingState
+		current.Status.EffectiveCWD = effectiveCWD
 		current.Status.PreviousSessionID = previousSessionID
 		current.Status.LastBoundAt = &now
 		current.Status.LastReplayMessageCount = replayMessageCount
@@ -496,6 +506,7 @@ func (s *server) bootstrapACPConversationBindingWithClient(ctx context.Context,
 	return &acpBootstrapResponse{
 		Conversation:       updatedConversation,
 		EffectiveSessionID: effectiveSessionID,
+		EffectiveCWD:       effectiveCWD,
 		BindingState:       bindingState,
 		Loaded:             loaded,
 		Replaced:           replaced,

api/acp_cwd.go

@@ -0,0 +1,164 @@
+package main
+
+import (
+	"net/url"
+	"path"
+	"strconv"
+	"strings"
+
+	spritzv1 "spritz.sh/operator/api/v1"
+)
+
+var legacyInheritedConversationCWDs = map[string]struct{}{
+	defaultACPCWD: {},
+	"/workspace":  {},
+}
+
+// normalizeConversationCWD trims client input and preserves empty values so the
+// conversation resource can distinguish "no override" from an explicit cwd.
+func normalizeConversationCWD(value string) string {
+	return strings.TrimSpace(value)
+}
+
+// resolveConversationEffectiveCWD resolves the cwd that should be used for ACP
+// bootstrap and reconnect flows after accounting for explicit overrides,
+// instance defaults, and legacy copied-default values.
+func resolveConversationEffectiveCWD(spritz *spritzv1.Spritz, conversation *spritzv1.SpritzConversation) string {
+	defaultCWD := resolveSpritzDefaultCWD(spritz)
+	if conversation == nil {
+		return defaultCWD
+	}
+	if override := normalizeConversationOverrideCWD(spritz, conversation.Spec.CWD); override != "" {
+		return override
+	}
+	return defaultCWD
+}
+
+// normalizeConversationOverrideCWD clears legacy copied defaults so bootstrap
+// can distinguish a real override from inherited instance state.
+func normalizeConversationOverrideCWD(spritz *spritzv1.Spritz, value string) string {
+	override := normalizeConversationCWD(value)
+	if override == "" {
+		return ""
+	}
+
+	defaultCWD := resolveSpritzDefaultCWD(spritz)
+	if override == defaultCWD {
+		return ""
+	}
+	if _, ok := legacyInheritedConversationCWDs[override]; ok && override != defaultCWD {
+		return ""
+	}
+	return override
+}
+
+// resolveSpritzDefaultCWD derives the runtime-owned default cwd from explicit
+// env overrides first and falls back to the primary repo checkout directory.
+func resolveSpritzDefaultCWD(spritz *spritzv1.Spritz) string {
+	if spritz == nil {
+		return defaultACPCWD
+	}
+
+	for _, key := range []string{
+		"SPRITZ_CONVERSATION_DEFAULT_CWD",
+		"SPRITZ_CODEX_WORKDIR",
+		"SPRITZ_CLAUDE_CODE_WORKDIR",
+		"SPRITZ_REPO_DIR",
+	} {
+		if value := spritzEnvValue(spritz, key); value != "" {
+			return value
+		}
+	}
+
+	if repoDir := resolvePrimaryRepoDir(spritz); repoDir != "" {
+		return repoDir
+	}
+	return defaultACPCWD
+}
+
+func spritzEnvValue(spritz *spritzv1.Spritz, key string) string {
+	if spritz == nil {
+		return ""
+	}
+	for i := len(spritz.Spec.Env) - 1; i >= 0; i-- {
+		env := spritz.Spec.Env[i]
+		if strings.TrimSpace(env.Name) != key {
+			continue
+		}
+		if value := strings.TrimSpace(env.Value); value != "" {
+			return value
+		}
+	}
+	return ""
+}
+
+func resolvePrimaryRepoDir(spritz *spritzv1.Spritz) string {
+	if spritz == nil {
+		return ""
+	}
+
+	repos := spritz.Spec.Repos
+	if len(repos) > 0 {
+		return repoDirForConversationDefault(repos[0], 0, len(repos))
+	}
+	if spritz.Spec.Repo != nil && strings.TrimSpace(spritz.Spec.Repo.URL) != "" {
+		return repoDirForConversationDefault(*spritz.Spec.Repo, 0, 1)
+	}
+	return ""
+}
+
+func repoDirForConversationDefault(repo spritzv1.SpritzRepo, index int, total int) string {
+	repoDir := strings.TrimSpace(repo.Dir)
+	if repoDir == "" {
+		if total > 1 {
+			repoDir = "/workspace/repo-" + strconv.Itoa(index+1)
+		} else if inferred := inferConversationRepoName(repo.URL); inferred != "" {
+			repoDir = path.Join("/workspace", inferred)
+		} else {
+			repoDir = "/workspace/repo"
+		}
+	}
+	if !strings.HasPrefix(repoDir, "/") {
+		repoDir = path.Join("/workspace", repoDir)
+	}
+	return path.Clean(repoDir)
+}
+
+func inferConversationRepoName(raw string) string {
+	value := strings.TrimSpace(raw)
+	if value == "" {
+		return ""
+	}
+	pathPart := ""
+	if strings.Contains(value, "://") {
+		parsed, err := url.Parse(value)
+		if err != nil {
+			return ""
+		}
+		pathPart = parsed.Path
+	} else if strings.Contains(value, ":") {
+		parts := strings.SplitN(value, ":", 2)
+		if len(parts) == 2 {
+			pathPart = parts[1]
+		} else {
+			pathPart = value
+		}
+	} else {
+		pathPart = value
+	}
+	pathPart = strings.SplitN(pathPart, "?", 2)[0]
+	pathPart = strings.SplitN(pathPart, "#", 2)[0]
+	pathPart = strings.TrimSuffix(pathPart, "/")
+	if pathPart == "" {
+		return ""
+	}
+	base := path.Base(pathPart)
+	if base == "." || base == "/" {
+		return ""
+	}
+	base = strings.TrimSuffix(base, ".git")
+	if base == "" || base == "." || base == "/" {
+		return ""
+	}
+	return base
+}

api/acp_helpers.go

@@ -72,14 +72,6 @@ func normalizeConversationCapabilities(status *spritzv1.SpritzACPStatus) *spritz
 	return capabilities
 }
 
-func normalizeConversationCWD(value string) string {
-	trimmed := strings.TrimSpace(value)
-	if trimmed == "" {
-		return defaultACPCWD
-	}
-	return trimmed
-}
-
 func conversationDisplayTitle(conversation *spritzv1.SpritzConversation) string {
 	if conversation == nil {
 		return defaultACPConversationTitle