fix(cloud): stop autosync false acknowledgements

Author: Alan-TheGentleman

cmd/engram/autosync_e2e_test.go

@@ -302,6 +302,10 @@ func (s *autosyncFakeStore) ListPendingSyncMutations(_ string, limit int) ([]sto
 	return result, nil
 }
 
+func (s *autosyncFakeStore) CountPendingNonEnrolledSyncMutations(_ string) ([]store.PendingSyncMutationProjectCount, error) {
+	return nil, nil
+}
+
 func (s *autosyncFakeStore) AckSyncMutations(_ string, _ int64) error { return nil }
 
 func (s *autosyncFakeStore) AckSyncMutationSeqs(_ string, seqs []int64) error {
@@ -334,6 +338,8 @@ func (s *autosyncFakeStore) ApplyPulledMutation(_ string, _ store.SyncMutation)
 
 func (s *autosyncFakeStore) MarkSyncFailure(_, _ string, _ time.Time) error { return nil }
 
+func (s *autosyncFakeStore) MarkSyncBlocked(_, _, _ string) error { return nil }
+
 func (s *autosyncFakeStore) MarkSyncHealthy(_ string) error { return nil }
 
 // httpPushMutations is a helper to push mutations directly to a test server.

cmd/engram/autosync_status.go

@@ -79,7 +79,11 @@ func (a *autosyncStatusAdapter) mapPhase(st autosync.Status) server.SyncStatus {
 		} else {
 			base.ReasonCode = "transport_failed"
 		}
-		base.ReasonMessage = st.LastError
+		if st.ReasonMessage != "" {
+			base.ReasonMessage = st.ReasonMessage
+		} else {
+			base.ReasonMessage = st.LastError
+		}
 
 	case autosync.PhaseDisabled:
 		base.Phase = "degraded"

cmd/engram/cloud.go

@@ -552,15 +552,46 @@ func cmdCloudStatus(cfg store.Config) {
 			fmt.Println("Auth status: ready (insecure local-dev mode: ENGRAM_CLOUD_INSECURE_NO_AUTH=1)")
 			fmt.Println("Sync readiness: ready for explicit --project sync (project must be enrolled)")
 			fmt.Println("Warning: bearer auth is disabled in insecure mode; do not use in production")
+			printCloudStatusSyncDiagnostic(cfg)
 			return
 		}
 		fmt.Println("Auth status: token not configured (client token is optional at preflight)")
 		fmt.Println("Sync readiness: ready to attempt explicit --project sync (project must be enrolled)")
 		fmt.Println("Hint: if the remote server enforces bearer auth, set ENGRAM_CLOUD_TOKEN")
+		printCloudStatusSyncDiagnostic(cfg)
 		return
 	}
 	fmt.Println("Auth status: ready (token provided via runtime cloud config)")
 	fmt.Println("Sync readiness: ready for explicit --project sync (project must be enrolled)")
+	printCloudStatusSyncDiagnostic(cfg)
+}
+
+func printCloudStatusSyncDiagnostic(cfg store.Config) {
+	if _, err := os.Stat(filepath.Join(cfg.DataDir, "engram.db")); err != nil {
+		return
+	}
+	s, err := storeNew(cfg)
+	if err != nil {
+		fmt.Printf("Sync diagnostic: unavailable (%v)\n", err)
+		return
+	}
+	defer s.Close()
+	state, err := s.GetSyncState(constants.TargetKeyCloud)
+	if err != nil || state == nil {
+		return
+	}
+	code := strings.TrimSpace(derefString(state.ReasonCode))
+	message := strings.TrimSpace(derefString(state.ReasonMessage))
+	if code == "" && message == "" {
+		return
+	}
+	fmt.Printf("Sync diagnostic: %s\n", state.Lifecycle)
+	if code != "" {
+		fmt.Printf("reason_code: %s\n", code)
+	}
+	if message != "" {
+		fmt.Printf("reason_message: %s\n", message)
+	}
 }
 
 func cmdCloudEnroll(cfg store.Config) {

cmd/engram/main_extra_test.go

@@ -1336,6 +1336,35 @@ func TestCmdCloudStatusHonorsEnvServerOverride(t *testing.T) {
 	}
 }
 
+func TestCmdCloudStatusSurfacesPersistedNonEnrolledPendingDiagnostic(t *testing.T) {
+	stubExitWithPanic(t)
+	stubRuntimeHooks(t)
+
+	cfg := testConfig(t)
+	t.Setenv("ENGRAM_CLOUD_SERVER", "https://env-cloud.example.test")
+	t.Setenv("ENGRAM_CLOUD_TOKEN", "env-token")
+	s, err := store.New(cfg)
+	if err != nil {
+		t.Fatalf("open store: %v", err)
+	}
+	if err := s.MarkSyncBlocked(store.DefaultSyncTargetKey, constants.ReasonNonEnrolledPendingMutations, "pending cloud sync mutations are blocked because project(s) are not enrolled: alpha=2. Run `engram cloud enroll <project>` for each intended project or review enrollment."); err != nil {
+		_ = s.Close()
+		t.Fatalf("mark blocked: %v", err)
+	}
+	_ = s.Close()
+
+	withArgs(t, "engram", "cloud", "status")
+	stdout, stderr, recovered := captureOutputAndRecover(t, func() { cmdCloud(cfg) })
+	if recovered != nil || stderr != "" {
+		t.Fatalf("cloud status should succeed, panic=%v stderr=%q", recovered, stderr)
+	}
+	for _, want := range []string{"Sync diagnostic: degraded", "reason_code: non_enrolled_pending_mutations", "engram cloud enroll <project>"} {
+		if !strings.Contains(stdout, want) {
+			t.Fatalf("expected cloud status output to contain %q, got %q", want, stdout)
+		}
+	}
+}
+
 func TestCmdCloudStatusRejectsInvalidEffectiveRuntimeServerURL(t *testing.T) {
 	stubExitWithPanic(t)
 	stubRuntimeHooks(t)

internal/cloud/autosync/manager.go

@@ -79,16 +79,25 @@ type PullMutationsResponse struct {
 type LocalStore interface {
 	GetSyncState(targetKey string) (*store.SyncState, error)
 	ListPendingSyncMutations(targetKey string, limit int) ([]store.SyncMutation, error)
+	CountPendingNonEnrolledSyncMutations(targetKey string) ([]store.PendingSyncMutationProjectCount, error)
 	AckSyncMutations(targetKey string, lastAckedSeq int64) error
 	AckSyncMutationSeqs(targetKey string, seqs []int64) error
-	SkipAckNonEnrolledMutations(targetKey string) (int64, error)
 	AcquireSyncLease(targetKey, owner string, ttl time.Duration, now time.Time) (bool, error)
 	ReleaseSyncLease(targetKey, owner string) error
 	ApplyPulledMutation(targetKey string, mutation store.SyncMutation) error
 	MarkSyncFailure(targetKey, message string, backoffUntil time.Time) error
+	MarkSyncBlocked(targetKey, reasonCode, message string) error
 	MarkSyncHealthy(targetKey string) error
 }
 
+type nonEnrolledPendingError struct {
+	counts []store.PendingSyncMutationProjectCount
+}
+
+func (e *nonEnrolledPendingError) Error() string {
+	return nonEnrolledPendingMessage(e.counts)
+}
+
 // CloudTransport is the subset of remote.MutationTransport methods the manager needs.
 type CloudTransport interface {
 	PushMutations(mutations []MutationEntry) (*PushMutationsResult, error)
@@ -388,6 +397,11 @@ func (m *Manager) cycle(ctx context.Context) {
 
 	// Push, then pull.
 	if err := m.push(ctx); err != nil {
+		var blocked *nonEnrolledPendingError
+		if errors.As(err, &blocked) {
+			m.recordBlocked(err.Error(), constants.ReasonNonEnrolledPendingMutations)
+			return
+		}
 		reasonCode := classifyTransportError(err)
 		m.recordFailureWithReason(autosyncFailureMessage(m.cfg.TargetKey, fmt.Sprintf("push: %v", err), err), reasonCode)
 		return
@@ -453,16 +467,18 @@ func (m *Manager) push(ctx context.Context) error {
 
 	m.setPhase(PhasePushing)
 
-	// Skip-ack mutations for non-enrolled projects.
-	if _, err := m.store.SkipAckNonEnrolledMutations(m.cfg.TargetKey); err != nil {
-		return fmt.Errorf("skip-ack non-enrolled: %w", err)
-	}
-
 	pending, err := m.store.ListPendingSyncMutations(m.cfg.TargetKey, m.cfg.PushBatchSize)
 	if err != nil {
 		return fmt.Errorf("list pending: %w", err)
 	}
 	if len(pending) == 0 {
+		counts, err := m.store.CountPendingNonEnrolledSyncMutations(m.cfg.TargetKey)
+		if err != nil {
+			return fmt.Errorf("count pending non-enrolled mutations: %w", err)
+		}
+		if len(counts) > 0 {
+			return &nonEnrolledPendingError{counts: counts}
+		}
 		return nil
 	}
 
@@ -589,6 +605,18 @@ func (m *Manager) recordFailureWithReason(msg, reasonCode string) {
 	_ = m.store.MarkSyncFailure(m.cfg.TargetKey, msg, bu)
 }
 
+func (m *Manager) recordBlocked(msg, reasonCode string) {
+	m.mu.Lock()
+	m.status.Phase = PhasePushFailed
+	m.status.LastError = msg
+	m.status.ReasonCode = reasonCode
+	m.status.ReasonMessage = msg
+	m.status.BackoffUntil = nil
+	m.mu.Unlock()
+
+	_ = m.store.MarkSyncBlocked(m.cfg.TargetKey, reasonCode, msg)
+}
+
 func (m *Manager) recordSuccess() {
 	now := time.Now()
 	m.mu.Lock()
@@ -604,6 +632,14 @@ func (m *Manager) recordSuccess() {
 	_ = m.store.MarkSyncHealthy(m.cfg.TargetKey)
 }
 
+func nonEnrolledPendingMessage(counts []store.PendingSyncMutationProjectCount) string {
+	parts := make([]string, 0, len(counts))
+	for _, count := range counts {
+		parts = append(parts, fmt.Sprintf("%s=%d", count.Project, count.Count))
+	}
+	return fmt.Sprintf("pending cloud sync mutations are blocked because project(s) are not enrolled: %s. Run `engram cloud enroll <project>` for each intended project or review enrollment.", strings.Join(parts, ", "))
+}
+
 // computeBackoff returns exponential backoff with ±25% jitter.
 // Formula: min(base * 2^(failures-1), maxBackoff) ± jitter where jitter ∈ [-base*0.25, +base*0.25]
 // BW1: ±25% means jitter can be negative, so result ∈ [base*0.75, base*1.25].