@lobehub/lobehub 2.0.0-next.342 → 2.0.0-next.343

package/CHANGELOG.md

@@ -2,6 +2,47 @@
 
 # Changelog
 
+## [Version 2.0.0-next.343](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.342...v2.0.0-next.343)
+
+<sup>Released on **2026-01-23**</sup>
+
+#### ♻ Code Refactoring
+
+- **misc**: Improve memory data with experience and identity.
+
+#### 🐛 Bug Fixes
+
+- **misc**: Fix scope issue.
+
+#### 💄 Styles
+
+- **misc**: Update share style.
+
+<br/>
+
+<details>
+<summary><kbd>Improvements and Fixes</kbd></summary>
+
+#### Code refactoring
+
+- **misc**: Improve memory data with experience and identity, closes [#11717](https://github.com/lobehub/lobe-chat/issues/11717) ([bdb3eb4](https://github.com/lobehub/lobe-chat/commit/bdb3eb4))
+
+#### What's fixed
+
+- **misc**: Fix scope issue, closes [#11719](https://github.com/lobehub/lobe-chat/issues/11719) ([17adde8](https://github.com/lobehub/lobe-chat/commit/17adde8))
+
+#### Styles
+
+- **misc**: Update share style, closes [#11716](https://github.com/lobehub/lobe-chat/issues/11716) ([3c70dfa](https://github.com/lobehub/lobe-chat/commit/3c70dfa))
+
+</details>
+
+<div align="right">
+
+[![](https://img.shields.io/badge/-BACK_TO_TOP-151515?style=flat-square)](#readme-top)
+
+</div>
+
 ## [Version 2.0.0-next.342](https://github.com/lobehub/lobe-chat/compare/v2.0.0-next.341...v2.0.0-next.342)
 
 <sup>Released on **2026-01-22**</sup>

package/changelog/v1.json

@@ -1,4 +1,16 @@
 [
+  {
+    "children": {
+      "improvements": [
+        "Update share style."
+      ],
+      "fixes": [
+        "Fix scope issue."
+      ]
+    },
+    "date": "2026-01-23",
+    "version": "2.0.0-next.343"
+  },
   {
     "children": {},
     "date": "2026-01-22",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lobehub/lobehub",
-  "version": "2.0.0-next.342",
+  "version": "2.0.0-next.343",
   "description": "LobeHub - an open-source,comprehensive AI Agent framework that supports speech synthesis, multimodal, and extensible Function Call plugin system. Supports one-click free deployment of your private ChatGPT/LLM web application.",
   "keywords": [
     "framework",

package/packages/database/src/models/__tests__/userMemories.test.ts

@@ -6,6 +6,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { idGenerator } from '@/database/utils/idGenerator';
 
+import { getTestDB } from '../../core/getTestDB';
 import {
   topics,
   userMemories,
@@ -24,7 +25,6 @@ import {
   CreateUserMemoryPreferenceParams,
   UserMemoryModel,
 } from '../userMemory';
-import { getTestDB } from '../../core/getTestDB';
 
 const serverDB: LobeChatDatabase = await getTestDB();
 
@@ -753,20 +753,27 @@ describe('UserMemoryModel', () => {
 
       await userMemoryModel.addIdentityEntry({
         base: { lastAccessedAt: now, tags: [] },
-        identity: { role: 'engineer', tags: ['alpha', 'beta'] },
+        identity: { relationship: 'self', role: 'engineer', tags: ['alpha', 'beta'] },
       });
       await userMemoryModel.addIdentityEntry({
         base: { lastAccessedAt: now, tags: [] },
-        identity: { role: 'engineer', tags: ['alpha'] },
+        identity: { relationship: 'self', role: 'engineer', tags: ['alpha'] },
       });
       await userMemoryModel.addIdentityEntry({
         base: { lastAccessedAt: now, tags: [] },
-        identity: { role: 'manager', tags: [] },
+        identity: { relationship: 'self', role: 'manager', tags: [] },
       });
 
+      // This should not be counted (different user)
       await anotherUserModel.addIdentityEntry({
         base: { lastAccessedAt: now, tags: [] },
-        identity: { role: 'engineer', tags: ['alpha'] },
+        identity: { relationship: 'self', role: 'engineer', tags: ['alpha'] },
+      });
+
+      // This should not be counted (relationship is not 'self')
+      await userMemoryModel.addIdentityEntry({
+        base: { lastAccessedAt: now, tags: [] },
+        identity: { relationship: 'friend', role: 'designer', tags: ['gamma'] },
       });
 
       const result = await userMemoryModel.queryIdentityRoles({ size: 5 });
@@ -1062,6 +1069,56 @@ describe('UserMemoryModel', () => {
       expect(identityItem.identity.userMemoryId).toBe(identityMemoryId);
       expect(identityItem.identity.type).toBe(identity?.type);
     });
+
+    it('should order identity memories by capturedAt desc and include capturedAt and title in response', async () => {
+      const olderCapturedAt = new Date('2024-01-01T10:00:00Z');
+      const newerCapturedAt = new Date('2024-01-15T10:00:00Z');
+
+      await userMemoryModel.addIdentityEntry({
+        base: { summary: 'older identity', title: 'Older Title' },
+        identity: {
+          capturedAt: olderCapturedAt,
+          description: 'Older identity description',
+          relationship: 'friend',
+          type: 'personal',
+        },
+      });
+
+      await userMemoryModel.addIdentityEntry({
+        base: { summary: 'newer identity', title: 'Newer Title' },
+        identity: {
+          capturedAt: newerCapturedAt,
+          description: 'Newer identity description',
+          relationship: 'self',
+          type: 'personal',
+        },
+      });
+
+      const result = await userMemoryModel.queryMemories({
+        layer: LayersEnum.Identity,
+      });
+
+      expect(result.total).toBe(2);
+      expect(result.items).toHaveLength(2);
+
+      const firstItem = result.items[0] as any;
+      const secondItem = result.items[1] as any;
+
+      // Verify order by capturedAt desc
+      expect(firstItem.identity.capturedAt).toEqual(newerCapturedAt);
+      expect(secondItem.identity.capturedAt).toEqual(olderCapturedAt);
+
+      expect(firstItem.identity.description).toBe('Newer identity description');
+      expect(secondItem.identity.description).toBe('Older identity description');
+
+      // Verify title comes from memory schema
+      expect(firstItem.identity.title).toBe('Newer Title');
+      expect(secondItem.identity.title).toBe('Older Title');
+
+      // Verify relationship is included
+      expect(firstItem.identity.relationship).toBe('self');
+      expect(secondItem.identity.relationship).toBe('friend');
+    });
   });
 
   describe('findById', () => {

package/packages/database/src/models/agentCronJob.ts

@@ -1,4 +1,4 @@
-import { and, desc, eq, gt, isNull, or, sql } from 'drizzle-orm';
+import { and, desc, eq, gt, inArray, isNull, or, sql } from 'drizzle-orm';
 
 import {
   type AgentCronJob,
@@ -25,8 +25,8 @@ export class AgentCronJobModel {
       .values({
         ...data,
         // Initialize remaining executions to match max executions
-remainingExecutions: data.maxExecutions,
-        
+        remainingExecutions: data.maxExecutions,
+
         userId: this.userId,
       } as NewAgentCronJob)
       .returning();
@@ -149,11 +149,11 @@ remainingExecutions: data.maxExecutions,
       .set({
         enabled: true,
         // Re-enable job when resetting
-lastExecutedAt: null,
-        
-maxExecutions: newMaxExecutions,
-        
-remainingExecutions: newMaxExecutions, 
+        lastExecutedAt: null,
+
+        maxExecutions: newMaxExecutions,
+
+        remainingExecutions: newMaxExecutions,
         totalExecutions: 0,
         updatedAt: new Date(),
       })
@@ -227,7 +227,7 @@ remainingExecutions: newMaxExecutions,
         enabled,
         updatedAt: new Date(),
       })
-      .where(and(sql`${agentCronJobs.id} = ANY(${ids})`, eq(agentCronJobs.userId, this.userId)))
+      .where(and(inArray(agentCronJobs.id, ids), eq(agentCronJobs.userId, this.userId)))
       .returning();
 
     return result.length;

package/packages/database/src/models/userMemory/__tests__/identity.test.ts

@@ -2,6 +2,7 @@
 import { RelationshipEnum } from '@lobechat/types';
 import { beforeEach, describe, expect, it } from 'vitest';
 
+import { getTestDB } from '../../../core/getTestDB';
 import {
   NewUserMemoryIdentity,
   userMemories,
@@ -9,7 +10,6 @@ import {
   users,
 } from '../../../schemas';
 import { LobeChatDatabase } from '../../../type';
-import { getTestDB } from '../../../core/getTestDB';
 import { UserMemoryIdentityModel } from '../identity';
 
 const userId = 'identity-test-user';
@@ -68,21 +68,21 @@ describe('UserMemoryIdentityModel', () => {
           userId,
           type: 'personal',
           description: 'Identity 1',
-          createdAt: new Date('2024-01-01T10:00:00Z'),
+          capturedAt: new Date('2024-01-01T10:00:00Z'),
         },
         {
           id: 'identity-2',
           userId,
           type: 'professional',
           description: 'Identity 2',
-          createdAt: new Date('2024-01-02T10:00:00Z'),
+          capturedAt: new Date('2024-01-02T10:00:00Z'),
         },
         {
           id: 'other-identity',
           userId: otherUserId,
           type: 'personal',
           description: 'Other Identity',
-          createdAt: new Date('2024-01-03T10:00:00Z'),
+          capturedAt: new Date('2024-01-03T10:00:00Z'),
         },
       ]);
     });
@@ -94,7 +94,7 @@ describe('UserMemoryIdentityModel', () => {
       expect(result.every((i) => i.userId === userId)).toBe(true);
     });
 
-    it('should order by createdAt desc', async () => {
+    it('should order by capturedAt desc', async () => {
       const result = await identityModel.query();
 
       expect(result[0].id).toBe('identity-2'); // Most recent first

package/packages/database/src/models/userMemory/experience.ts

@@ -1,4 +1,5 @@
-import { and, desc, eq } from 'drizzle-orm';
+import type { ExperienceListParams, ExperienceListResult } from '@lobechat/types';
+import { type SQL, and, asc, desc, eq, ilike, inArray, or, sql } from 'drizzle-orm';
 
 import {
   NewUserMemoryExperience,
@@ -64,6 +65,95 @@ export class UserMemoryExperienceModel {
     });
   };
 
+  /**
+   * Query experience list with pagination, search, and sorting
+   * Returns a flat structure optimized for frontend display
+   */
+  queryList = async (params: ExperienceListParams = {}): Promise<ExperienceListResult> => {
+    const { order = 'desc', page = 1, pageSize = 20, q, sort, tags, types } = params;
+
+    const normalizedPage = Math.max(1, page);
+    const normalizedPageSize = Math.min(Math.max(pageSize, 1), 100);
+    const offset = (normalizedPage - 1) * normalizedPageSize;
+    const normalizedQuery = typeof q === 'string' ? q.trim() : '';
+
+    // Build WHERE conditions
+    const conditions: Array<SQL | undefined> = [
+      eq(userMemoriesExperiences.userId, this.userId),
+      // Full-text search across title, situation, keyLearning, action
+      normalizedQuery
+        ? or(
+            ilike(userMemories.title, `%${normalizedQuery}%`),
+            ilike(userMemoriesExperiences.situation, `%${normalizedQuery}%`),
+            ilike(userMemoriesExperiences.keyLearning, `%${normalizedQuery}%`),
+            ilike(userMemoriesExperiences.action, `%${normalizedQuery}%`),
+          )
+        : undefined,
+      types && types.length > 0 ? inArray(userMemoriesExperiences.type, types) : undefined,
+      tags && tags.length > 0
+        ? or(...tags.map((tag) => sql<boolean>`${tag} = ANY(${userMemoriesExperiences.tags})`))
+        : undefined,
+    ];
+
+    const filters = conditions.filter((condition): condition is SQL => condition !== undefined);
+    const whereClause = filters.length > 0 ? and(...filters) : undefined;
+
+    // Build ORDER BY
+    const applyOrder = order === 'asc' ? asc : desc;
+    const sortColumn =
+      sort === 'scoreConfidence'
+        ? userMemoriesExperiences.scoreConfidence
+        : userMemoriesExperiences.capturedAt;
+
+    const orderByClauses = [
+      applyOrder(sortColumn),
+      applyOrder(userMemoriesExperiences.updatedAt),
+      applyOrder(userMemoriesExperiences.createdAt),
+    ];
+
+    // JOIN condition
+    const joinCondition = and(
+      eq(userMemories.id, userMemoriesExperiences.userMemoryId),
+      eq(userMemories.userId, this.userId),
+    );
+
+    // Execute queries in parallel
+    const [rows, totalResult] = await Promise.all([
+      this.db
+        .select({
+          action: userMemoriesExperiences.action,
+          capturedAt: userMemoriesExperiences.capturedAt,
+          createdAt: userMemoriesExperiences.createdAt,
+          id: userMemoriesExperiences.id,
+          keyLearning: userMemoriesExperiences.keyLearning,
+          scoreConfidence: userMemoriesExperiences.scoreConfidence,
+          situation: userMemoriesExperiences.situation,
+          tags: userMemoriesExperiences.tags,
+          title: userMemories.title,
+          type: userMemoriesExperiences.type,
+          updatedAt: userMemoriesExperiences.updatedAt,
+        })
+        .from(userMemoriesExperiences)
+        .innerJoin(userMemories, joinCondition)
+        .where(whereClause)
+        .orderBy(...orderByClauses)
+        .limit(normalizedPageSize)
+        .offset(offset),
+      this.db
+        .select({ count: sql<number>`COUNT(*)::int` })
+        .from(userMemoriesExperiences)
+        .innerJoin(userMemories, joinCondition)
+        .where(whereClause),
+    ]);
+
+    return {
+      items: rows,
+      page: normalizedPage,
+      pageSize: normalizedPageSize,
+      total: Number(totalResult[0]?.count ?? 0),
+    };
+  };
+
   findById = async (id: string) => {
     return this.db.query.userMemoriesExperiences.findFirst({
       where: and(

package/packages/database/src/models/userMemory/identity.ts

@@ -1,5 +1,6 @@
+import type { IdentityListParams, IdentityListResult } from '@lobechat/types';
 import { RelationshipEnum } from '@lobechat/types';
-import { and, desc, eq, isNull, or } from 'drizzle-orm';
+import { type SQL, and, asc, desc, eq, ilike, inArray, isNull, or, sql } from 'drizzle-orm';
 
 import {
   NewUserMemoryIdentity,
@@ -60,11 +61,101 @@ export class UserMemoryIdentityModel {
   query = async (limit = 50) => {
     return this.db.query.userMemoriesIdentities.findMany({
       limit,
-      orderBy: [desc(userMemoriesIdentities.createdAt)],
+      orderBy: [desc(userMemoriesIdentities.capturedAt)],
       where: eq(userMemoriesIdentities.userId, this.userId),
     });
   };
 
+  /**
+   * Query identity list with pagination, search, and sorting
+   * Returns a flat structure optimized for frontend display
+   */
+  queryList = async (params: IdentityListParams = {}): Promise<IdentityListResult> => {
+    const { order = 'desc', page = 1, pageSize = 20, q, relationships, sort, tags, types } = params;
+
+    const normalizedPage = Math.max(1, page);
+    const normalizedPageSize = Math.min(Math.max(pageSize, 1), 100);
+    const offset = (normalizedPage - 1) * normalizedPageSize;
+    const normalizedQuery = typeof q === 'string' ? q.trim() : '';
+
+    // Build WHERE conditions
+    const conditions: Array<SQL | undefined> = [
+      eq(userMemoriesIdentities.userId, this.userId),
+      // Full-text search across title, description, role
+      normalizedQuery
+        ? or(
+            ilike(userMemories.title, `%${normalizedQuery}%`),
+            ilike(userMemoriesIdentities.description, `%${normalizedQuery}%`),
+            ilike(userMemoriesIdentities.role, `%${normalizedQuery}%`),
+          )
+        : undefined,
+      types && types.length > 0 ? inArray(userMemoriesIdentities.type, types) : undefined,
+      // Default to 'self' relationship if not specified
+      relationships && relationships.length > 0
+        ? inArray(userMemoriesIdentities.relationship, relationships)
+        : eq(userMemoriesIdentities.relationship, RelationshipEnum.Self),
+      tags && tags.length > 0
+        ? or(...tags.map((tag) => sql<boolean>`${tag} = ANY(${userMemoriesIdentities.tags})`))
+        : undefined,
+    ];
+
+    const filters = conditions.filter((condition): condition is SQL => condition !== undefined);
+    const whereClause = filters.length > 0 ? and(...filters) : undefined;
+
+    // Build ORDER BY
+    const applyOrder = order === 'asc' ? asc : desc;
+    const sortColumn =
+      sort === 'type' ? userMemoriesIdentities.type : userMemoriesIdentities.capturedAt;
+
+    const orderByClauses = [
+      applyOrder(sortColumn),
+      applyOrder(userMemoriesIdentities.updatedAt),
+      applyOrder(userMemoriesIdentities.createdAt),
+    ];
+
+    // JOIN condition
+    const joinCondition = and(
+      eq(userMemories.id, userMemoriesIdentities.userMemoryId),
+      eq(userMemories.userId, this.userId),
+    );
+
+    // Execute queries in parallel
+    const [rows, totalResult] = await Promise.all([
+      this.db
+        .select({
+          capturedAt: userMemoriesIdentities.capturedAt,
+          createdAt: userMemoriesIdentities.createdAt,
+          description: userMemoriesIdentities.description,
+          episodicDate: userMemoriesIdentities.episodicDate,
+          id: userMemoriesIdentities.id,
+          relationship: userMemoriesIdentities.relationship,
+          role: userMemoriesIdentities.role,
+          tags: userMemoriesIdentities.tags,
+          title: userMemories.title,
+          type: userMemoriesIdentities.type,
+          updatedAt: userMemoriesIdentities.updatedAt,
+        })
+        .from(userMemoriesIdentities)
+        .innerJoin(userMemories, joinCondition)
+        .where(whereClause)
+        .orderBy(...orderByClauses)
+        .limit(normalizedPageSize)
+        .offset(offset),
+      this.db
+        .select({ count: sql<number>`COUNT(*)::int` })
+        .from(userMemoriesIdentities)
+        .innerJoin(userMemories, joinCondition)
+        .where(whereClause),
+    ]);
+
+    return {
+      items: rows,
+      page: normalizedPage,
+      pageSize: normalizedPageSize,
+      total: Number(totalResult[0]?.count ?? 0),
+    };
+  };
+
   findById = async (id: string) => {
     return this.db.query.userMemoriesIdentities.findFirst({
       where: and(eq(userMemoriesIdentities.id, id), eq(userMemoriesIdentities.userId, this.userId)),

package/packages/database/src/models/userMemory/model.ts

@@ -311,6 +311,7 @@ export interface QueryIdentityRolesResult {
 }
 
 export type QueryUserMemoriesSort =
+  | 'capturedAt' // all layers
   | 'scoreConfidence' // user_memories_experiences
   | 'scoreImpact' // user_memories_contexts
   | 'scorePriority' // user_memories_preferences
@@ -668,7 +669,10 @@ export class UserMemoryModel {
     const { page = 1, size = 10 } = params;
     const offset = (page - 1) * size;
 
-    const identityConditions = [eq(userMemoriesIdentities.userId, this.userId)];
+    const identityConditions = [
+      eq(userMemoriesIdentities.userId, this.userId),
+      eq(userMemoriesIdentities.relationship, RelationshipEnum.Self),
+    ];
 
     const identityTags = this.db.$with('identity_tags').as(
       this.db
@@ -792,7 +796,9 @@ export class UserMemoryModel {
         const scoreColumn =
           sort === 'scoreUrgency'
             ? userMemoriesContexts.scoreUrgency
-            : userMemoriesContexts.scoreImpact;
+            : sort === 'scoreImpact'
+              ? userMemoriesContexts.scoreImpact
+              : userMemoriesContexts.capturedAt;
 
         const orderByClauses = buildOrderBy(
           scoreColumn,
@@ -880,8 +886,13 @@ export class UserMemoryModel {
         };
       }
       case LayersEnum.Experience: {
+        const scoreColumn =
+          sort === 'scoreConfidence'
+            ? userMemoriesExperiences.scoreConfidence
+            : userMemoriesExperiences.capturedAt;
+
         const orderByClauses = buildOrderBy(
-          userMemoriesExperiences.scoreConfidence,
+          scoreColumn,
           userMemoriesExperiences.updatedAt,
           userMemoriesExperiences.createdAt,
         );
@@ -956,7 +967,7 @@ export class UserMemoryModel {
       case LayersEnum.Identity: {
         const orderByClauses = buildOrderBy(
           undefined,
-          userMemoriesIdentities.updatedAt,
+          userMemoriesIdentities.capturedAt,
           userMemoriesIdentities.createdAt,
         );
         const joinCondition = and(
@@ -986,6 +997,7 @@ export class UserMemoryModel {
             .select({
               identity: {
                 accessedAt: userMemoriesIdentities.accessedAt,
+                capturedAt: userMemoriesIdentities.capturedAt,
                 createdAt: userMemoriesIdentities.createdAt,
                 description: userMemoriesIdentities.description,
                 episodicDate: userMemoriesIdentities.episodicDate,
@@ -994,6 +1006,7 @@ export class UserMemoryModel {
                 relationship: userMemoriesIdentities.relationship,
                 role: userMemoriesIdentities.role,
                 tags: userMemoriesIdentities.tags,
+                title: userMemories.title,
                 type: userMemoriesIdentities.type,
                 updatedAt: userMemoriesIdentities.updatedAt,
                 userId: userMemoriesIdentities.userId,
@@ -1028,8 +1041,13 @@ export class UserMemoryModel {
         };
       }
       case LayersEnum.Preference: {
+        const scoreColumn =
+          sort === 'scorePriority'
+            ? userMemoriesPreferences.scorePriority
+            : userMemoriesPreferences.capturedAt;
+
         const orderByClauses = buildOrderBy(
-          userMemoriesPreferences.scorePriority,
+          scoreColumn,
           userMemoriesPreferences.updatedAt,
           userMemoriesPreferences.createdAt,
         );
@@ -1226,6 +1244,7 @@ export class UserMemoryModel {
         const [identity] = await this.db
           .select({
             accessedAt: userMemoriesIdentities.accessedAt,
+            capturedAt: userMemoriesIdentities.capturedAt,
             createdAt: userMemoriesIdentities.createdAt,
             description: userMemoriesIdentities.description,
             episodicDate: userMemoriesIdentities.episodicDate,
@@ -1933,7 +1952,7 @@ export class UserMemoryModel {
       .select(selectNonVectorColumns(userMemoriesIdentities))
       .from(userMemoriesIdentities)
       .where(eq(userMemoriesIdentities.userId, this.userId))
-      .orderBy(desc(userMemoriesIdentities.createdAt));
+      .orderBy(desc(userMemoriesIdentities.capturedAt));
 
     return res;
   };
@@ -1947,7 +1966,7 @@ export class UserMemoryModel {
       .from(userMemoriesIdentities)
       .innerJoin(userMemories, eq(userMemories.id, userMemoriesIdentities.userMemoryId))
       .where(eq(userMemoriesIdentities.userId, this.userId))
-      .orderBy(desc(userMemoriesIdentities.createdAt));
+      .orderBy(desc(userMemoriesIdentities.capturedAt));
 
     return res as Array<{
       identity: typeof userMemoriesIdentities.$inferSelect;
@@ -1962,7 +1981,7 @@ export class UserMemoryModel {
       .where(
         and(eq(userMemoriesIdentities.userId, this.userId), eq(userMemoriesIdentities.type, type)),
       )
-      .orderBy(desc(userMemoriesIdentities.createdAt));
+      .orderBy(desc(userMemoriesIdentities.capturedAt));
 
     return res;
   };

package/packages/types/src/userMemory/experience.ts

@@ -0,0 +1,25 @@
+import type { BaseListItem, BaseListParams, BaseListResult } from './shared';
+
+/**
+ * Experience query types for list display
+ * These are flat structures optimized for frontend rendering
+ */
+
+export type ExperienceListSort = 'capturedAt' | 'scoreConfidence';
+
+export interface ExperienceListParams extends BaseListParams {
+  sort?: ExperienceListSort;
+}
+
+/**
+ * Flat structure for experience list items
+ * Contains fields needed for card display, excluding detail fields like reasoning/possibleOutcome
+ */
+export interface ExperienceListItem extends BaseListItem {
+  action: string | null;
+  keyLearning: string | null;
+  scoreConfidence: number | null;
+  situation: string | null;
+}
+
+export type ExperienceListResult = BaseListResult<ExperienceListItem>;

package/packages/types/src/userMemory/identity.ts

@@ -1,7 +1,34 @@
 import { z } from 'zod';
 
+import type { BaseListItem, BaseListParams, BaseListResult } from './shared';
+
 export type IdentityType = 'personal' | 'professional' | 'demographic';
 
+/**
+ * Identity query types for list display
+ * These are flat structures optimized for frontend rendering
+ */
+
+export type IdentityListSort = 'capturedAt' | 'type';
+
+export interface IdentityListParams extends BaseListParams {
+  relationships?: string[];
+  sort?: IdentityListSort;
+}
+
+/**
+ * Flat structure for identity list items
+ * Contains fields needed for card display
+ */
+export interface IdentityListItem extends BaseListItem {
+  description: string | null;
+  episodicDate: Date | null;
+  relationship: string | null;
+  role: string | null;
+}
+
+export type IdentityListResult = BaseListResult<IdentityListItem>;
+
 export interface UserMemoryIdentity {
   accessedAt: Date;
   createdAt: Date;

package/packages/types/src/userMemory/index.ts

@@ -1,4 +1,5 @@
 export * from './base';
+export * from './experience';
 export * from './identity';
 export * from './layers';
 export * from './list';