fix timezones in threads (#11498)

## Description

Fix thread timestamps being returned in incorrect timezone from
`listThreadsByResourceId`.

The `listThreadsByResourceId` method was not selecting or using the
timezone-aware columns (`createdAtZ`/`updatedAtZ` which are
`TIMESTAMPTZ` type). This caused timestamps to be read from the
`TIMESTAMP WITHOUT TIME ZONE` columns and interpreted in local timezone
instead of UTC.

The fix updates `listThreadsByResourceId` to:
1. Select the timezone-aware columns (`createdAtZ`, `updatedAtZ`)
2. Use them with fallback for legacy data (matching the pattern already
used in `getThreadById`)

## Related Issue(s)

#11496

## Type of Change

- [x] Bug fix (non-breaking change that fixes an issue)
- [ ] New feature (non-breaking change that adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update
- [ ] Code refactoring
- [ ] Performance improvement
- [x] Test update

## Checklist

- [x] I have made corresponding changes to the documentation (if
applicable)
- [x] I have added tests that prove my fix is effective or that my
feature works

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

* **Bug Fixes**
* Patched @mastra/pg to fix thread timestamp handling by implementing
timezone-aware timestamp columns with automatic fallback support for
legacy data, ensuring consistent timestamp values across operations

* **Tests**
* Added comprehensive test to verify timestamp consistency across thread
retrieval operations, confirming that created and updated timestamps
remain synchronized across different data access methods

<sub>✏️ Tip: You can customize this high-level summary in your review
settings.</sub>

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: graysonhicks

.changeset/lemon-turtles-sort.md

@@ -0,0 +1,7 @@
+---
+'@mastra/pg': patch
+---
+
+Fix thread timestamps being returned in incorrect timezone from listThreadsByResourceId
+
+The method was not using the timezone-aware columns (createdAtZ/updatedAtZ), causing timestamps to be interpreted in local timezone instead of UTC. Now correctly uses TIMESTAMPTZ columns with fallback for legacy data.

stores/_test-utils/src/domains/memory/threads.ts

@@ -103,6 +103,47 @@ export function createThreadsTest({ storage }: { storage: MastraStorage }) {
       expect(retrievedThread).toEqual(updatedThread);
     });
 
+    it('should return consistent timestamps from getThreadById and listThreadsByResourceId (issue #11496)', async () => {
+      // This test verifies that timestamps are consistent across different retrieval methods.
+      // The bug was that listThreadsByResourceId returned timestamps from non-timezone-aware columns,
+      // while getThreadById used timezone-aware columns, causing inconsistent UTC timestamps.
+
+      const thread = createSampleThread();
+      await memoryStorage.saveThread({ thread });
+
+      // Update the thread to ensure updatedAt differs from createdAt
+      await new Promise(resolve => setTimeout(resolve, 50));
+      const updatedThread = await memoryStorage.updateThread({
+        id: thread.id,
+        title: 'Updated for timestamp test',
+        metadata: { timestampTest: true },
+      });
+
+      // Get thread via getThreadById
+      const threadById = await memoryStorage.getThreadById({ threadId: thread.id });
+
+      // Get thread via listThreadsByResourceId
+      const { threads } = await memoryStorage.listThreadsByResourceId({
+        resourceId: thread.resourceId,
+        page: 0,
+        perPage: 10,
+      });
+      const threadFromList = threads.find(t => t.id === thread.id);
+
+      expect(threadById).toBeDefined();
+      expect(threadFromList).toBeDefined();
+
+      // Normalize to timestamps for comparison (handles both Date objects and ISO strings)
+      const getTimestamp = (date: Date | string) => (date instanceof Date ? date.getTime() : new Date(date).getTime());
+
+      // The timestamps should be identical between the two retrieval methods
+      expect(getTimestamp(threadFromList!.createdAt)).toBe(getTimestamp(threadById!.createdAt));
+      expect(getTimestamp(threadFromList!.updatedAt)).toBe(getTimestamp(threadById!.updatedAt));
+
+      // Also verify updatedAt from updateThread matches
+      expect(getTimestamp(threadFromList!.updatedAt)).toBe(getTimestamp(updatedThread.updatedAt));
+    });
+
     it('should delete thread', async () => {
       const thread = createSampleThread();
       await memoryStorage.saveThread({ thread });

stores/pg/src/storage/domains/memory/index.ts

@@ -239,14 +239,21 @@ export class MemoryPG extends MemoryStorage {
       }
 
       const limitValue = perPageInput === false ? total : perPage;
-      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "updatedAt" ${baseQuery} ORDER BY "${field}" ${direction} LIMIT $2 OFFSET $3`;
-      const rows = await this.#db.client.manyOrNone(dataQuery, [...queryParams, limitValue, offset]);
+      // Select both standard and timezone-aware columns (*Z) for proper UTC timestamp handling
+      const dataQuery = `SELECT id, "resourceId", title, metadata, "createdAt", "createdAtZ", "updatedAt", "updatedAtZ" ${baseQuery} ORDER BY "${field}" ${direction} LIMIT $2 OFFSET $3`;
+      const rows = await this.#db.client.manyOrNone<StorageThreadType & { createdAtZ: Date; updatedAtZ: Date }>(
+        dataQuery,
+        [...queryParams, limitValue, offset],
+      );
 
       const threads = (rows || []).map(thread => ({
-        ...thread,
+        id: thread.id,
+        resourceId: thread.resourceId,
+        title: thread.title,
         metadata: typeof thread.metadata === 'string' ? JSON.parse(thread.metadata) : thread.metadata,
-        createdAt: thread.createdAt,
-        updatedAt: thread.updatedAt,
+        // Use timezone-aware columns (*Z) for correct UTC timestamps, with fallback for legacy data
+        createdAt: thread.createdAtZ || thread.createdAt,
+        updatedAt: thread.updatedAtZ || thread.updatedAt,
       }));
 
       return {