fix(acp): preserve explicit cwd overrides

Author: onutc

api/acp_bootstrap.go

@@ -481,7 +481,7 @@ func (s *server) bootstrapACPConversationBindingWithClient(
 
 	updatedConversation, err := s.updateConversationBinding(ctx, conversation.Namespace, conversation.Name, func(current *spritzv1.SpritzConversation) {
 		now := metav1.Now()
-		current.Spec.CWD = normalizeConversationOverrideCWD(spritz, current.Spec.CWD)
+		setConversationCWDOverride(current, normalizeConversationOverrideCWD(spritz, current))
 		current.Spec.SessionID = effectiveSessionID
 		current.Spec.AgentInfo = agentInfo
 		current.Spec.Capabilities = capabilities

api/acp_config.go

@@ -17,6 +17,7 @@ const (
 	acpConversationLabelValue     = "true"
 	acpConversationSpritzLabelKey = "spritz.sh/spritz-name"
 	acpConversationOwnerLabelKey  = ownerLabelKey
+	acpConversationExplicitCWDKey = "spritz.sh/acp-cwd-override-explicit"
 )
 
 type acpConfig struct {

api/acp_conversations.go

@@ -165,9 +165,14 @@ func (s *server) updateACPConversation(c echo.Context) error {
 		}
 		changed = true
 	}
-	if body.CWD != nil && conversation.Spec.CWD != normalizeConversationCWD(*body.CWD) {
-		conversation.Spec.CWD = normalizeConversationCWD(*body.CWD)
-		changed = true
+	if body.CWD != nil {
+		nextCWD := normalizeConversationCWD(*body.CWD)
+		nextExplicit := nextCWD != ""
+		currentExplicit := conversationHasExplicitCWDOverride(conversation)
+		if conversation.Spec.CWD != nextCWD || currentExplicit != nextExplicit {
+			setConversationCWDOverride(conversation, *body.CWD)
+			changed = true
+		}
 	}
 	if changed {
 		if err := s.client.Update(c.Request().Context(), conversation); err != nil {

api/acp_cwd.go

@@ -9,11 +9,6 @@ import (
 	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 {
@@ -28,25 +23,28 @@ func resolveConversationEffectiveCWD(spritz *spritzv1.Spritz, conversation *spri
 	if conversation == nil {
 		return defaultCWD
 	}
-	if override := normalizeConversationOverrideCWD(spritz, conversation.Spec.CWD); override != "" {
+	if override := normalizeConversationOverrideCWD(spritz, conversation); 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)
+// normalizeConversationOverrideCWD distinguishes an explicit override from an
+// inherited instance default without guessing about ambiguous historical values.
+func normalizeConversationOverrideCWD(spritz *spritzv1.Spritz, conversation *spritzv1.SpritzConversation) string {
+	if conversation == nil {
+		return ""
+	}
+	override := normalizeConversationCWD(conversation.Spec.CWD)
 	if override == "" {
 		return ""
 	}
 
 	defaultCWD := resolveSpritzDefaultCWD(spritz)
-	if override == defaultCWD {
-		return ""
+	if conversationHasExplicitCWDOverride(conversation) {
+		return override
 	}
-	if _, ok := legacyInheritedConversationCWDs[override]; ok && override != defaultCWD {
+	if override == defaultCWD {
 		return ""
 	}
 	return override
@@ -162,3 +160,33 @@ func inferConversationRepoName(raw string) string {
 	}
 	return base
 }
+
+func conversationHasExplicitCWDOverride(conversation *spritzv1.SpritzConversation) bool {
+	if conversation == nil || conversation.Annotations == nil {
+		return false
+	}
+	value := strings.TrimSpace(conversation.Annotations[acpConversationExplicitCWDKey])
+	switch strings.ToLower(value) {
+	case "1", "true", "yes", "on":
+		return true
+	default:
+		return false
+	}
+}
+
+func setConversationCWDOverride(conversation *spritzv1.SpritzConversation, value string) {
+	if conversation == nil {
+		return
+	}
+	conversation.Spec.CWD = normalizeConversationCWD(value)
+	if conversation.Spec.CWD == "" {
+		if conversation.Annotations != nil {
+			delete(conversation.Annotations, acpConversationExplicitCWDKey)
+		}
+		return
+	}
+	if conversation.Annotations == nil {
+		conversation.Annotations = map[string]string{}
+	}
+	conversation.Annotations[acpConversationExplicitCWDKey] = "true"
+}

api/acp_helpers.go

@@ -122,7 +122,7 @@ func buildACPConversationResource(spritz *spritzv1.Spritz, requestedTitle, reque
 	if title == "" {
 		title = defaultACPConversationTitle
 	}
-	return &spritzv1.SpritzConversation{
+	conversation := &spritzv1.SpritzConversation{
 		TypeMeta: metav1.TypeMeta{
 			APIVersion: spritzv1.GroupVersion.String(),
 			Kind:       "SpritzConversation",
@@ -153,7 +153,9 @@ func buildACPConversationResource(spritz *spritzv1.Spritz, requestedTitle, reque
 		Status: spritzv1.SpritzConversationStatus{
 			BindingState: "pending",
 		},
-	}, nil
+	}
+	setConversationCWDOverride(conversation, requestedCWD)
+	return conversation, nil
 }
 
 func (s *server) getAuthorizedSpritz(ctx context.Context, principal principal, namespace, name string) (*spritzv1.Spritz, error) {

api/acp_test.go

@@ -699,15 +699,15 @@ func TestBootstrapACPConversationLoadsStoredSessionWithoutMutatingIdentity(t *te
 	}
 }
 
-func TestBootstrapACPConversationNormalizesLegacyHomeCWDToResolvedDefault(t *testing.T) {
+func TestBootstrapACPConversationUsesResolvedDefaultWhenOverrideMissing(t *testing.T) {
 	spritz := readyACPSpritz("tidy-otter", "user-1")
 	spritz.Spec.Repo = &spritzv1.SpritzRepo{
 		URL: "https://example.com/open/spritz.git",
 		Dir: "/workspace/platform",
 	}
 	conversation := conversationFor("tidy-otter-conv", "tidy-otter", "user-1", "Latest", metav1.Now())
 	conversation.Spec.SessionID = "session-existing"
-	conversation.Spec.CWD = "/home/dev"
+	conversation.Spec.CWD = ""
 	fakeACP := newFakeACPBootstrapServer(t, fakeACPBootstrapServerOptions{})
 
 	s := newACPTestServer(t, spritz, conversation)
@@ -746,6 +746,53 @@ func TestBootstrapACPConversationNormalizesLegacyHomeCWDToResolvedDefault(t *tes
 	}
 }
 
+func TestBootstrapACPConversationPreservesExplicitWorkspaceOverride(t *testing.T) {
+	spritz := readyACPSpritz("tidy-otter", "user-1")
+	spritz.Spec.Repo = &spritzv1.SpritzRepo{
+		URL: "https://example.com/open/spritz.git",
+		Dir: "/workspace/platform",
+	}
+	conversation := conversationFor("tidy-otter-conv", "tidy-otter", "user-1", "Latest", metav1.Now())
+	conversation.Spec.SessionID = "session-existing"
+	setConversationCWDOverride(conversation, "/workspace")
+	fakeACP := newFakeACPBootstrapServer(t, fakeACPBootstrapServerOptions{})
+
+	s := newACPTestServer(t, spritz, conversation)
+	s.acp.instanceURL = func(namespace, name string) string { return fakeACP.url }
+
+	e := echo.New()
+	secured := e.Group("", s.authMiddleware())
+	secured.POST("/api/acp/conversations/:id/bootstrap", s.bootstrapACPConversation)
+
+	req := httptest.NewRequest(http.MethodPost, "/api/acp/conversations/"+conversation.Name+"/bootstrap", nil)
+	req.Header.Set("X-Spritz-User-Id", "user-1")
+	rec := httptest.NewRecorder()
+	e.ServeHTTP(rec, req)
+
+	if rec.Code != http.StatusOK {
+		t.Fatalf("expected status 200, got %d: %s", rec.Code, rec.Body.String())
+	}
+
+	var payload struct {
+		Status string `json:"status"`
+		Data   struct {
+			EffectiveCWD string `json:"effectiveCwd"`
+		} `json:"data"`
+	}
+	if err := json.Unmarshal(rec.Body.Bytes(), &payload); err != nil {
+		t.Fatalf("failed to decode bootstrap response: %v", err)
+	}
+	if payload.Data.EffectiveCWD != "/workspace" {
+		t.Fatalf("expected explicit cwd override to be preserved, got %q", payload.Data.EffectiveCWD)
+	}
+
+	fakeACP.mu.Lock()
+	defer fakeACP.mu.Unlock()
+	if len(fakeACP.loadCWDs) != 1 || fakeACP.loadCWDs[0] != "/workspace" {
+		t.Fatalf("expected session/load cwd /workspace, got %#v", fakeACP.loadCWDs)
+	}
+}
+
 func TestBootstrapACPConversationRepairsMissingSessionExplicitly(t *testing.T) {
 	spritz := readyACPSpritz("tidy-otter", "user-1")
 	conversation := conversationFor("tidy-otter-conv", "tidy-otter", "user-1", "Latest", metav1.Now())

ui/src/pages/chat.test.tsx

@@ -734,6 +734,12 @@ describe('ChatPage draft persistence', () => {
         expect.objectContaining({ effectiveCwd: '/workspace/platform' }),
       );
     });
+
+    fireEvent.click(screen.getByRole('button', { name: 'Needs CWD' }));
+
+    await waitFor(() => {
+      expect(countBootstrapCalls('conv-cwd')).toBe(1);
+    });
   });
 
   it('surfaces terminal bootstrap failures without retrying again in the background', async () => {

ui/src/pages/chat.tsx

@@ -257,6 +257,30 @@ export function ChatPage() {
     );
   }, []);
 
+  const applyConversationUpdate = useCallback((conversation: ConversationInfo) => {
+    setSelectedConversation(conversation);
+    setAgents((prev) =>
+      prev.map((group) => {
+        const sameSpritz = group.spritz.metadata.name === (conversation.spec?.spritzName || '');
+        const hasConversation = group.conversations.some((item) => item.metadata.name === conversation.metadata.name);
+        if (!sameSpritz && !hasConversation) {
+          return group;
+        }
+        const nextConversations = hasConversation
+          ? group.conversations.map((item) =>
+              item.metadata.name === conversation.metadata.name ? conversation : item,
+            )
+          : sameSpritz
+            ? [...group.conversations, conversation]
+            : group.conversations;
+        return {
+          ...group,
+          conversations: sortConversationsByRecency(nextConversations),
+        };
+      }),
+    );
+  }, []);
+
   const {
     transcript,
     clientReady,
@@ -270,7 +294,7 @@ export function ChatPage() {
     conversation: selectedConversation,
     apiBaseUrl: config.apiBaseUrl || '',
     websocketBaseUrl: config.websocketBaseUrl || '',
-    onConversationUpdate: setSelectedConversation,
+    onConversationUpdate: applyConversationUpdate,
     onConversationTitle: applyConversationTitle,
   });