@lobehub/lobehub 2.0.0-next.251 → 2.0.0-next.253

package/packages/database/src/models/__tests__/topics/topic.create.test.ts

@@ -1,10 +1,10 @@
 import { eq, inArray } from 'drizzle-orm';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
+import { getTestDB } from '../../../core/getTestDB';
 import { agents, messages, sessions, topics, users } from '../../../schemas';
 import { LobeChatDatabase } from '../../../type';
 import { CreateTopicParams, TopicModel } from '../../topic';
-import { getTestDB } from '../../../core/getTestDB';
 
 const userId = 'topic-create-user';
 const userId2 = 'topic-create-user-2';
@@ -68,11 +68,17 @@ describe('TopicModel - Create', () => {
       expect(dbTopic).toHaveLength(1);
       expect(dbTopic[0]).toEqual(createdTopic);
 
-      const associatedMessages = await serverDB.select().from(messages).where(inArray(messages.id, topicData.messages!));
+      const associatedMessages = await serverDB
+        .select()
+        .from(messages)
+        .where(inArray(messages.id, topicData.messages!));
       expect(associatedMessages).toHaveLength(2);
       expect(associatedMessages.every((msg) => msg.topicId === topicId)).toBe(true);
 
-      const unassociatedMessage = await serverDB.select().from(messages).where(eq(messages.id, 'message3'));
+      const unassociatedMessage = await serverDB
+        .select()
+        .from(messages)
+        .where(eq(messages.id, 'message3'));
       expect(unassociatedMessage[0].topicId).toBeNull();
     });
 
@@ -169,8 +175,18 @@ describe('TopicModel - Create', () => {
       const createdTopics = await topicModel.batchCreate(topicParams);
 
       expect(createdTopics).toHaveLength(2);
-      expect(createdTopics[0]).toMatchObject({ title: 'Topic 1', favorite: true, sessionId, userId });
-      expect(createdTopics[1]).toMatchObject({ title: 'Topic 2', favorite: false, sessionId, userId });
+      expect(createdTopics[0]).toMatchObject({
+        title: 'Topic 1',
+        favorite: true,
+        sessionId,
+        userId,
+      });
+      expect(createdTopics[1]).toMatchObject({
+        title: 'Topic 2',
+        favorite: false,
+        sessionId,
+        userId,
+      });
 
       const items = await serverDB.select().from(topics);
       expect(items).toHaveLength(2);
@@ -216,7 +232,15 @@ describe('TopicModel - Create', () => {
       expect(createdTopics[1].agentId).toBe('batch-agent-2');
       expect(createdTopics[1].sessionId).toBeNull();
 
-      const dbTopics = await serverDB.select().from(topics).where(inArray(topics.id, createdTopics.map((t) => t.id)));
+      const dbTopics = await serverDB
+        .select()
+        .from(topics)
+        .where(
+          inArray(
+            topics.id,
+            createdTopics.map((t) => t.id),
+          ),
+        );
       expect(dbTopics).toHaveLength(2);
       expect(dbTopics.find((t) => t.id === createdTopics[0].id)?.agentId).toBe('batch-agent-1');
       expect(dbTopics.find((t) => t.id === createdTopics[1].id)?.agentId).toBe('batch-agent-2');
@@ -236,7 +260,10 @@ describe('TopicModel - Create', () => {
         ]);
       });
 
-      const { topic: duplicatedTopic, messages: duplicatedMessages } = await topicModel.duplicate(topicId, newTitle);
+      const { topic: duplicatedTopic, messages: duplicatedMessages } = await topicModel.duplicate(
+        topicId,
+        newTitle,
+      );
 
       expect(duplicatedTopic.id).not.toBe(topicId);
       expect(duplicatedTopic.title).toBe(newTitle);
@@ -255,7 +282,9 @@ describe('TopicModel - Create', () => {
     it('should throw an error if the topic to duplicate does not exist', async () => {
       const topicId = 'nonexistent-topic';
 
-      await expect(topicModel.duplicate(topicId)).rejects.toThrow(`Topic with id ${topicId} not found`);
+      await expect(topicModel.duplicate(topicId)).rejects.toThrow(
+        `Topic with id ${topicId} not found`,
+      );
     });
   });
 });

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

@@ -27,8 +27,10 @@ export interface CreateTopicParams {
   favorite?: boolean;
   groupId?: string | null;
   messages?: string[];
+  metadata?: ChatTopicMetadata;
   sessionId?: string | null;
   title?: string;
+  trigger?: string | null;
 }
 
 interface QueryTopicParams {
@@ -39,6 +41,10 @@ interface QueryTopicParams {
    */
   containerId?: string | null;
   current?: number;
+  /**
+   * Exclude topics by trigger types (e.g. ['cron'])
+   */
+  excludeTriggers?: string[];
   /**
    * Group ID to filter topics by
    */
@@ -70,15 +76,24 @@ export class TopicModel {
     agentId,
     containerId,
     current = 0,
+    excludeTriggers,
     pageSize = 9999,
     groupId,
     isInbox,
   }: QueryTopicParams = {}) => {
     const offset = current * pageSize;
+    const excludeTriggerCondition =
+      excludeTriggers && excludeTriggers.length > 0
+        ? or(isNull(topics.trigger), not(inArray(topics.trigger, excludeTriggers)))
+        : undefined;
 
     // If groupId is provided, query topics by groupId directly
     if (groupId) {
-      const whereCondition = and(eq(topics.userId, this.userId), eq(topics.groupId, groupId));
+      const whereCondition = and(
+        eq(topics.userId, this.userId),
+        eq(topics.groupId, groupId),
+        excludeTriggerCondition,
+      );
 
       const [items, totalResult] = await Promise.all([
         this.db
@@ -155,21 +170,25 @@ export class TopicModel {
             updatedAt: topics.updatedAt,
           })
           .from(topics)
-          .where(and(eq(topics.userId, this.userId), agentCondition))
+          .where(and(eq(topics.userId, this.userId), agentCondition, excludeTriggerCondition))
           .orderBy(desc(topics.favorite), desc(topics.updatedAt))
           .limit(pageSize)
           .offset(offset),
         this.db
           .select({ count: count(topics.id) })
           .from(topics)
-          .where(and(eq(topics.userId, this.userId), agentCondition)),
+          .where(and(eq(topics.userId, this.userId), agentCondition, excludeTriggerCondition)),
       ]);
 
       return { items, total: totalResult[0].count };
     }
 
     // Fallback to containerId-based query (backward compatibility)
-    const whereCondition = and(eq(topics.userId, this.userId), this.matchContainer(containerId));
+    const whereCondition = and(
+      eq(topics.userId, this.userId),
+      this.matchContainer(containerId),
+      excludeTriggerCondition,
+    );
 
     const [items, totalResult] = await Promise.all([
       this.db
@@ -664,4 +683,52 @@ export class TopicModel {
       ),
     });
   };
+
+  /**
+   * Get cron topics grouped by cronJob for a specific agent
+   * Returns topics where trigger='cron' and metadata contains cronJobId
+   */
+  getCronTopicsGroupedByCronJob = async (agentId: string) => {
+    const cronTopics = await this.db
+      .select({
+        createdAt: topics.createdAt,
+        favorite: topics.favorite,
+        historySummary: topics.historySummary,
+        id: topics.id,
+        metadata: topics.metadata,
+        title: topics.title,
+        trigger: topics.trigger,
+        updatedAt: topics.updatedAt,
+      })
+      .from(topics)
+      .where(
+        and(
+          eq(topics.userId, this.userId),
+          eq(topics.agentId, agentId),
+          eq(topics.trigger, 'cron'),
+          // Check if metadata contains cronJobId
+          sql`${topics.metadata}->>'cronJobId' IS NOT NULL`,
+        ),
+      )
+      .orderBy(desc(topics.updatedAt));
+
+    // Group topics by cronJobId
+    const groupedTopics = new Map<string, typeof cronTopics>();
+
+    cronTopics.forEach((topic) => {
+      const cronJobId = topic.metadata?.cronJobId;
+      if (cronJobId) {
+        if (!groupedTopics.has(cronJobId)) {
+          groupedTopics.set(cronJobId, []);
+        }
+        groupedTopics.get(cronJobId)!.push(topic);
+      }
+    });
+
+    // Convert Map to array of grouped objects
+    return Array.from(groupedTopics.entries()).map(([cronJobId, topicList]) => ({
+      cronJobId,
+      topics: topicList,
+    }));
+  };
 }

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

@@ -32,8 +32,7 @@ export const agentCronJobs = pgTable(
     agentId: text('agent_id')
       .references(() => agents.id, { onDelete: 'cascade' })
       .notNull(),
-    groupId: text('group_id')
-      .references(() => chatGroups.id, { onDelete: 'cascade' }),
+    groupId: text('group_id').references(() => chatGroups.id, { onDelete: 'cascade' }),
     userId: text('user_id')
       .references(() => users.id, { onDelete: 'cascade' })
       .notNull(),

package/packages/electron-client-ipc/src/events/system.ts

@@ -4,4 +4,5 @@ export interface SystemBroadcastEvents {
   localeChanged: (data: { locale: string }) => void;
   systemThemeChanged: (data: { themeMode: ThemeAppearance }) => void;
   themeChanged: (data: { themeMode: ThemeMode }) => void;
+  windowFocused: () => void;
 }

package/packages/memory-user-memory/src/extractors/context.ts

@@ -16,10 +16,7 @@ export class ContextExtractor extends BaseMemoryExtractor<ContextMemory> {
   }
 
   getSchema() {
-    return buildGenerateObjectSchema(
-      ContextMemorySchema,
-      { name: 'context_extraction' },
-    );
+    return buildGenerateObjectSchema(ContextMemorySchema, { name: 'context_extraction' });
   }
 
   getResultSchema() {

package/packages/memory-user-memory/src/extractors/experience.ts

@@ -1,10 +1,7 @@
 import { renderPlaceholderTemplate } from '@lobechat/context-engine';
 
 import { experiencePrompt } from '../prompts';
-import {
-  ExperienceMemory,
-  ExperienceMemorySchema
-} from '../schemas';
+import { ExperienceMemory, ExperienceMemorySchema } from '../schemas';
 import { ExtractorTemplateProps } from '../types';
 import { buildGenerateObjectSchema } from '../utils/zod';
 import { BaseMemoryExtractor } from './base';
@@ -19,10 +16,7 @@ export class ExperienceExtractor extends BaseMemoryExtractor<ExperienceMemory> {
   }
 
   getSchema() {
-    return buildGenerateObjectSchema(
-      ExperienceMemorySchema,
-      { name: 'experience_extraction' },
-    );
+    return buildGenerateObjectSchema(ExperienceMemorySchema, { name: 'experience_extraction' });
   }
 
   getResultSchema() {

package/packages/memory-user-memory/src/extractors/preference.ts

@@ -1,10 +1,7 @@
 import { renderPlaceholderTemplate } from '@lobechat/context-engine';
 
-import {
-  PreferenceMemory,
-  PreferenceMemorySchema,
-} from '../schemas';
 import { preferencePrompt } from '../prompts';
+import { PreferenceMemory, PreferenceMemorySchema } from '../schemas';
 import { ExtractorTemplateProps } from '../types';
 import { buildGenerateObjectSchema } from '../utils/zod';
 import { BaseMemoryExtractor } from './base';
@@ -19,10 +16,7 @@ export class PreferenceExtractor extends BaseMemoryExtractor<PreferenceMemory> {
   }
 
   getSchema() {
-    return buildGenerateObjectSchema(
-      PreferenceMemorySchema,
-      { name: 'preference_extraction' },
-    );
+    return buildGenerateObjectSchema(PreferenceMemorySchema, { name: 'preference_extraction' });
   }
 
   getResultSchema() {

package/packages/memory-user-memory/src/prompts/gatekeeper.ts

@@ -1,127 +1,127 @@
 export const gatekeeperPrompt = [
-  "You are a \"gate keeper\" that analyzes conversations between user and assistant to determine which memory layers contain extractable information worth storing.",
-  "",
-  "Your role is to efficiently filter conversations by identifying which of the five memory layers are present and valuable enough to extract.",
-  "",
-  "Bias toward sensitivity: when in doubt, prefer setting `shouldExtract: true` so downstream extractors can refine. Minor, incremental or clarifying updates should still be allowed to pass.",
-  "",
-  "## Memory Layer Definitions",
-  "",
-  "Evaluate the conversation for these memory layers:",
-  "",
-  "**Activity Layer** - Episodic events with clear timelines and participants:",
-  "",
-  "- Meetings, calls, errands, and appointments with start/end times",
-  "- Locations (physical or virtual) and timezones",
-  "- Status (planned, completed) and follow-up actions",
-  "- Narratives summarizing what happened and feedback/notes",
-  "",
-  "**Identity Layer** - Information about actors, relationships, and personal attributes:",
-  "",
-  "- Describing labels and demographics",
-  "- Current focusing and life priorities",
-  "- Relationships with other people",
-  "- Background and experience",
-  "- Roles in various contexts",
-  "- Identity should remain compact. Route lists of tools, stacks, or",
-  "  implementation techniques to the preference layer unless they materially",
+  'You are a "gate keeper" that analyzes conversations between user and assistant to determine which memory layers contain extractable information worth storing.',
+  '',
+  'Your role is to efficiently filter conversations by identifying which of the five memory layers are present and valuable enough to extract.',
+  '',
+  'Bias toward sensitivity: when in doubt, prefer setting `shouldExtract: true` so downstream extractors can refine. Minor, incremental or clarifying updates should still be allowed to pass.',
+  '',
+  '## Memory Layer Definitions',
+  '',
+  'Evaluate the conversation for these memory layers:',
+  '',
+  '**Activity Layer** - Episodic events with clear timelines and participants:',
+  '',
+  '- Meetings, calls, errands, and appointments with start/end times',
+  '- Locations (physical or virtual) and timezones',
+  '- Status (planned, completed) and follow-up actions',
+  '- Narratives summarizing what happened and feedback/notes',
+  '',
+  '**Identity Layer** - Information about actors, relationships, and personal attributes:',
+  '',
+  '- Describing labels and demographics',
+  '- Current focusing and life priorities',
+  '- Relationships with other people',
+  '- Background and experience',
+  '- Roles in various contexts',
+  '- Identity should remain compact. Route lists of tools, stacks, or',
+  '  implementation techniques to the preference layer unless they materially',
   "  change the user's biography.",
-  "",
-  "**Context Layer** - Only capture brand-new situational frameworks and ongoing situations that have not been recorded before:",
-  "",
-  "- Distinct situations, topics, research threads, sessions, or rounds that are clearly first-time mentions",
-  "- Ongoing projects and their status when the project itself is new, not just progress updates",
-  "- Long-term goals and objectives that are newly introduced",
-  "- Persistent relationships and dynamics that have not been logged previously",
-  "- Environmental factors and recurring situations only when they represent a new context",
-  "- Timelines and temporal context that establish a novel situation",
-  "- Impact and urgency assessments tied to a new context",
-  "- If the content overlaps with learnings or takeaways, treat it as Experience instead of Context",
-  "",
-  "**Preference Layer** - Durable user choices and behavioral directives that apply across multiple conversations:",
-  "",
-  "- Explicit long-term preferences with clear temporal markers (e.g., \"always\", \"never\", \"from now on\")",
-  "- Likes and dislikes stated as persistent traits (e.g., \"I prefer...\", \"I don't like...\")",
-  "- Workflow and approach preferences explicitly stated as ongoing (what to do, not how to implement)",
-  "- Communication style preferences explicitly stated as ongoing",
-  "- Response formatting preferences explicitly stated as ongoing",
-  "- Priority levels for preference resolution",
-  "- Capture recurring tool/stacks/technology usage as preferences rather than",
-  "  duplicating them as identity facts.",
-  "",
-  "Note: Task-specific requirements, constraints for a single object/entity, or one-time instructions do NOT belong to this layer.",
-  "",
-  "**Experience Layer** - Learned insights and practical knowledge worth reusing and",
-  "sharing publicly:",
-  "",
-  "- Lessons learned and insights gained, especially surprising aha/yurika moments",
-  "- Practical tricks and techniques that solve tough or non-obvious problems",
-  "- Transferable knowledge and wisdom that would make a strong blog/knowledge-base",
-  "  snippet",
-  "- Situation → Reasoning → Action → Outcome patterns",
-  "- Key learnings from experiences with self-assessed confidence/impact",
-  "- Skip routine or repetitive steps already well covered in retrieved memories",
-  "",
-  "## Gate Keeping Guidelines",
-  "",
-  "For each layer, consider:",
-  "",
-  "- **Relevance**: Does the conversation contain information for this layer?",
-  "- **Value**: Is the information substantial enough to be worth extracting?",
-  "- **Clarity**: Is the information clear and extractable (not vague or ambiguous)?",
-  "",
-  "Additionally, review the retrieved similar memories first (top {{ topK }} items below). If the conversation content is clearly and fully covered by existing memories with no meaningful nuance or update, set `shouldExtract: false`.",
-  "For the Experience layer, prefer `shouldExtract: true` only when the conversation adds a new takeaway, aha moment, or harder challenge resolution beyond what is already recorded.",
-  "For the Context layer specifically, favor `shouldExtract: false` unless the conversation introduces a genuinely new situation/topic/research/session that is not already represented in existing context memories or overlaps with Experience items.",
-  "Otherwise, favor `shouldExtract: true` for:",
-  "",
-  "- Novel facts OR even small clarifications/precision improvements to existing details",
-  "- Incremental changes to status/progress of an ongoing context",
-  "- A new preference OR a refinement that affects future behavior",
-  "- Distinct experiences/lessons, even if closely related to prior items",
-  "",
-  "Preference-specific filters (STRICT - when in doubt, set shouldExtract: false):",
-  "",
-  "CRITICAL: Distinguish between \"user's behavioral preferences\" vs. \"task requirements for a specific deliverable\":",
-  "",
-  "- If the instruction describes what the OUTPUT should be like (e.g., \"name should have natural vibe\", \"don't use surname\"), it's a task requirement, NOT a user preference.",
-  "- If the instruction describes how the ASSISTANT should behave across conversations (e.g., \"always explain before coding\", \"never use jargon\"), it's a preference.",
-  "",
-  "Specific exclusion rules:",
-  "",
+  '',
+  '**Context Layer** - Only capture brand-new situational frameworks and ongoing situations that have not been recorded before:',
+  '',
+  '- Distinct situations, topics, research threads, sessions, or rounds that are clearly first-time mentions',
+  '- Ongoing projects and their status when the project itself is new, not just progress updates',
+  '- Long-term goals and objectives that are newly introduced',
+  '- Persistent relationships and dynamics that have not been logged previously',
+  '- Environmental factors and recurring situations only when they represent a new context',
+  '- Timelines and temporal context that establish a novel situation',
+  '- Impact and urgency assessments tied to a new context',
+  '- If the content overlaps with learnings or takeaways, treat it as Experience instead of Context',
+  '',
+  '**Preference Layer** - Durable user choices and behavioral directives that apply across multiple conversations:',
+  '',
+  '- Explicit long-term preferences with clear temporal markers (e.g., "always", "never", "from now on")',
+  '- Likes and dislikes stated as persistent traits (e.g., "I prefer...", "I don\'t like...")',
+  '- Workflow and approach preferences explicitly stated as ongoing (what to do, not how to implement)',
+  '- Communication style preferences explicitly stated as ongoing',
+  '- Response formatting preferences explicitly stated as ongoing',
+  '- Priority levels for preference resolution',
+  '- Capture recurring tool/stacks/technology usage as preferences rather than',
+  '  duplicating them as identity facts.',
+  '',
+  'Note: Task-specific requirements, constraints for a single object/entity, or one-time instructions do NOT belong to this layer.',
+  '',
+  '**Experience Layer** - Learned insights and practical knowledge worth reusing and',
+  'sharing publicly:',
+  '',
+  '- Lessons learned and insights gained, especially surprising aha/yurika moments',
+  '- Practical tricks and techniques that solve tough or non-obvious problems',
+  '- Transferable knowledge and wisdom that would make a strong blog/knowledge-base',
+  '  snippet',
+  '- Situation → Reasoning → Action → Outcome patterns',
+  '- Key learnings from experiences with self-assessed confidence/impact',
+  '- Skip routine or repetitive steps already well covered in retrieved memories',
+  '',
+  '## Gate Keeping Guidelines',
+  '',
+  'For each layer, consider:',
+  '',
+  '- **Relevance**: Does the conversation contain information for this layer?',
+  '- **Value**: Is the information substantial enough to be worth extracting?',
+  '- **Clarity**: Is the information clear and extractable (not vague or ambiguous)?',
+  '',
+  'Additionally, review the retrieved similar memories first (top {{ topK }} items below). If the conversation content is clearly and fully covered by existing memories with no meaningful nuance or update, set `shouldExtract: false`.',
+  'For the Experience layer, prefer `shouldExtract: true` only when the conversation adds a new takeaway, aha moment, or harder challenge resolution beyond what is already recorded.',
+  'For the Context layer specifically, favor `shouldExtract: false` unless the conversation introduces a genuinely new situation/topic/research/session that is not already represented in existing context memories or overlaps with Experience items.',
+  'Otherwise, favor `shouldExtract: true` for:',
+  '',
+  '- Novel facts OR even small clarifications/precision improvements to existing details',
+  '- Incremental changes to status/progress of an ongoing context',
+  '- A new preference OR a refinement that affects future behavior',
+  '- Distinct experiences/lessons, even if closely related to prior items',
+  '',
+  'Preference-specific filters (STRICT - when in doubt, set shouldExtract: false):',
+  '',
+  'CRITICAL: Distinguish between "user\'s behavioral preferences" vs. "task requirements for a specific deliverable":',
+  '',
+  '- If the instruction describes what the OUTPUT should be like (e.g., "name should have natural vibe", "don\'t use surname"), it\'s a task requirement, NOT a user preference.',
+  '- If the instruction describes how the ASSISTANT should behave across conversations (e.g., "always explain before coding", "never use jargon"), it\'s a preference.',
+  '',
+  'Specific exclusion rules:',
+  '',
   "- Do NOT treat the conversation's language as a preference unless the user explicitly states a persistent preference for language.",
-  "- Exclude one-off task instructions and implementation steps; these are not preferences.",
-  "- Exclude task-specific constraints, requirements, or clarifications (e.g., \"don't use surname Wang\", \"make it summer-themed\", \"natural vibe\") - these describe the current task deliverable, not user's persistent preferences.",
-  "- Exclude requirements or attributes for a specific object/entity being discussed (e.g., naming a cat, designing a logo) - these are task parameters, not user preferences.",
-  "- Exclude in-conversation clarifications or corrections (e.g., user first says X, then says \"no, not X\") - these refine the current task, not future behavior.",
-  "- Only extract when the user uses explicit preference markers like \"I always...\", \"I prefer...\", \"I never...\", \"from now on...\", \"please always...\" that clearly indicate cross-session intent.",
-  "- If the preference is about how to complete THIS specific task rather than how to behave in FUTURE tasks, exclude it.",
-  "- Ask yourself: \"Would this apply to a completely different conversation topic?\" If no, it's not a preference.",
-  "",
-  "Examples of what NOT to extract:",
-  "",
-  "- User asks for a cat name with \"natural vibe\" and \"born in summer\" → NOT a preference (task constraint)",
-  "- User says \"don't use surname Wang\" for naming → NOT a preference (task clarification)",
-  "- User wants a \"minimalist design\" for this logo → NOT a preference (task requirement)",
-  "",
-  "Examples of what TO extract:",
-  "",
-  "- \"I always prefer concise responses\" → IS a preference (cross-session directive)",
-  "- \"Never use technical jargon when explaining to me\" → IS a preference (persistent rule)",
-  "- \"From now on, please format code with comments\" → IS a preference (ongoing instruction)",
-  "",
-  "If uncertain about novelty, but information is relevant and clear, set `shouldExtract: true` and include a short reasoning.",
-  "",
-  "## Output Guidelines",
-  "",
-  "For each memory layer (activity, identity, context, preference, experience), provide:",
-  "",
-  "- `shouldExtract`: Boolean indicating whether extraction is recommended",
-  "- `reasoning`: Brief explanation of your decision (write in English)",
-  "",
-  "## Retrieved Memory (Top {{ topK }})",
-  "",
-  "Use the list below as context for deduplication and to determine whether extraction is necessary. Do not repeat these verbatim unless needed for comparison.",
-  "",
-  "{{ retrievedContext }}",
+  '- Exclude one-off task instructions and implementation steps; these are not preferences.',
+  '- Exclude task-specific constraints, requirements, or clarifications (e.g., "don\'t use surname Wang", "make it summer-themed", "natural vibe") - these describe the current task deliverable, not user\'s persistent preferences.',
+  '- Exclude requirements or attributes for a specific object/entity being discussed (e.g., naming a cat, designing a logo) - these are task parameters, not user preferences.',
+  '- Exclude in-conversation clarifications or corrections (e.g., user first says X, then says "no, not X") - these refine the current task, not future behavior.',
+  '- Only extract when the user uses explicit preference markers like "I always...", "I prefer...", "I never...", "from now on...", "please always..." that clearly indicate cross-session intent.',
+  '- If the preference is about how to complete THIS specific task rather than how to behave in FUTURE tasks, exclude it.',
+  '- Ask yourself: "Would this apply to a completely different conversation topic?" If no, it\'s not a preference.',
+  '',
+  'Examples of what NOT to extract:',
+  '',
+  '- User asks for a cat name with "natural vibe" and "born in summer" → NOT a preference (task constraint)',
+  '- User says "don\'t use surname Wang" for naming → NOT a preference (task clarification)',
+  '- User wants a "minimalist design" for this logo → NOT a preference (task requirement)',
+  '',
+  'Examples of what TO extract:',
+  '',
+  '- "I always prefer concise responses" → IS a preference (cross-session directive)',
+  '- "Never use technical jargon when explaining to me" → IS a preference (persistent rule)',
+  '- "From now on, please format code with comments" → IS a preference (ongoing instruction)',
+  '',
+  'If uncertain about novelty, but information is relevant and clear, set `shouldExtract: true` and include a short reasoning.',
+  '',
+  '## Output Guidelines',
+  '',
+  'For each memory layer (activity, identity, context, preference, experience), provide:',
+  '',
+  '- `shouldExtract`: Boolean indicating whether extraction is recommended',
+  '- `reasoning`: Brief explanation of your decision (write in English)',
+  '',
+  '## Retrieved Memory (Top {{ topK }})',
+  '',
+  'Use the list below as context for deduplication and to determine whether extraction is necessary. Do not repeat these verbatim unless needed for comparison.',
+  '',
+  '{{ retrievedContext }}',
 ].join('\n');