dsh-qqchat 0.2.4 → 0.2.6

package/lib/session/agent-bridge.js

@@ -1,7 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { createRequire } from 'node:module';
 import { installModelSelection } from '@deepseek-ai/dsh-agent';
-import { resolveSessionPreset } from '@deepseek-ai/dsh-agent-presets';
+import { agentPresetProjectionDefinition } from '@deepseek-ai/dsh-agent-presets';
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { SessionId } from '@deepseek-ai/dsh-session';
 import '../shared/augmentations.js';
@@ -12,7 +12,10 @@ import { dispatchQQCommand, qqCommandText, slashCommandName } from '../commands/
 import { MEMORY_SNAPSHOT_TTL_MS, memorySnapshotHash, restoreMemorySnapshotState, shouldRefreshMemorySnapshot } from './memory-snapshot.js';
 const DSH_RUNTIME_CONTEXT_SOURCE = '@deepseek-ai/dsh-system-prompt';
 export function resolveQQSessionPreset(header, events) {
-    return resolveSessionPreset({ header, events });
+    let current = agentPresetProjectionDefinition.init(header);
+    for (const event of events)
+        current = agentPresetProjectionDefinition.apply(current, event);
+    return current || undefined;
 }
 const MEDIA_TOOL_NAMES = new Set(['qqchat_describe_image', 'qqchat_read_file', 'qqchat_media_info']);
 const packageMetadata = createRequire(import.meta.url)('../../package.json');
@@ -33,8 +36,8 @@ export class DshQQBridge {
     activeAttachments = new Map();
     activeMediaReadable = new Map();
     memorySnapshots = new Map();
-    qqWorkspace;
     disposeEvent;
+    disposeAssistantStream;
     disposeToolGate;
     disposeCommands;
     disposeImageTool;
@@ -46,6 +49,11 @@ export class DshQQBridge {
         this.config = config;
         this.logger = logger;
         this.disposeEvent = ctx.on('session/event', (session, event) => this.onSessionEvent(session, event));
+        this.disposeAssistantStream = ctx.on('agent/assistant-stream', ({ agent, frame }) => {
+            if (frame.type !== 'chunk' || frame.chunk.type !== 'text-delta' || !frame.chunk.text)
+                return;
+            this.pending.get(String(agent.id))?.onTextDelta?.(frame.chunk.text);
+        });
         this.disposeToolGate = ctx.on('tools/pre-execute', async (exec, next) => {
             const agent = exec.agent;
             if (!agent)
@@ -72,8 +80,19 @@ export class DshQQBridge {
         this.disposeMediaTools = registerQQMediaTools(ctx, db, canReadMedia);
         this.disposeCommands = this.registerCommands();
     }
+    async attachMappedSessionsToWorkspace() {
+        const sessionIds = [
+            ...this.db.listGroups().map(row => row.dsh_session_id),
+            ...this.db.listDirectChats().map(row => row.dsh_session_id),
+        ];
+        for (const sessionId of sessionIds) {
+            if (sessionId)
+                await this.attachToWorkspace(sessionId);
+        }
+    }
     async dispose() {
         this.disposeEvent();
+        this.disposeAssistantStream();
         this.disposeToolGate();
         this.disposeImageTool();
         this.disposeMediaTools();
@@ -98,16 +117,6 @@ export class DshQQBridge {
         const { sessionId } = await this.ensureAgent(chatType, row);
         return sessionId;
     }
-    async ensureWorkspaceMembership() {
-        const sessionIds = [
-            ...this.db.listGroups().map(row => row.dsh_session_id),
-            ...this.db.listDirectChats().map(row => row.dsh_session_id),
-        ];
-        for (const sessionId of sessionIds) {
-            if (sessionId)
-                await this.attachToQQWorkspace(sessionId);
-        }
-    }
     async recordTranscript(event, row, createSession = false) {
         const existing = this.db.getChatSession(event.chatType, Number(row.id));
         if (!existing && !createSession)
@@ -223,13 +232,6 @@ export class DshQQBridge {
                 pending.text = text;
             return;
         }
-        if (event.type === 'assistant/chunk') {
-            const pending = this.pending.get(id);
-            const chunk = event.data.chunk;
-            if (pending?.onTextDelta && chunk.type === 'text-delta' && chunk.text)
-                pending.onTextDelta(chunk.text);
-            return;
-        }
         if (event.type === 'request/header') {
             const { config } = event.data.header;
             if (config.provider && config.model)
@@ -261,7 +263,7 @@ export class DshQQBridge {
         this.memorySnapshots.set(sessionId, previous);
     }
     restoreMemorySnapshot(session) {
-        return restoreMemorySnapshotState(session.events, DSH_RUNTIME_CONTEXT_SOURCE);
+        return restoreMemorySnapshotState(session.snapshotEvents(), DSH_RUNTIME_CONTEXT_SOURCE);
     }
     async ensureAgent(chatType, row) {
         let sessionId = this.db.getChatSession(chatType, Number(row.id));
@@ -284,16 +286,16 @@ export class DshQQBridge {
             if (live) {
                 this.ensureSelection(live);
                 this.ensureTitle(live.session, chatType, row);
+                await this.attachToWorkspace(sessionId);
                 this.rememberRoute(chatType, row, live, sessionId);
-                await this.attachToQQWorkspace(sessionId);
                 return { agent: live, sessionId };
             }
             const resumed = await this.tryResume(sessionId);
             if (resumed) {
                 this.ensureSelection(resumed.agent);
                 this.ensureTitle(resumed.agent.session, chatType, row);
+                await this.attachToWorkspace(sessionId);
                 this.rememberRoute(chatType, row, resumed.agent, sessionId);
-                await this.attachToQQWorkspace(sessionId);
                 return { agent: resumed.agent, sessionId };
             }
         }
@@ -310,36 +312,27 @@ export class DshQQBridge {
         this.handles.set(sessionId, handle);
         this.ensureSelection(handle.agent);
         this.db.setChatSession(chatType, Number(row.id), sessionId);
+        await this.attachToWorkspace(sessionId);
         this.ensureTitle(handle.agent.session, chatType, row);
         this.rememberRoute(chatType, row, handle.agent, sessionId);
-        await this.attachToQQWorkspace(sessionId);
         return { agent: handle.agent, sessionId };
     }
-    /** Keep all QQ sessions together in one DSH Workspace using the host API. */
-    async attachToQQWorkspace(sessionId) {
+    isArchived(sessionId) {
+        const registry = this.ctx.workspaceRegistry;
+        return registry?.archivedSessionIds.includes(sessionId) ?? false;
+    }
+    async attachToWorkspace(sessionId) {
         const registry = this.ctx.workspaceRegistry;
         if (!registry)
             return;
-        if (!this.qqWorkspace) {
-            this.qqWorkspace = registry.create(process.cwd(), 'QQ Chat').catch(error => {
-                this.logger.warn?.(`[dsh-qqchat] QQ Workspace 创建失败，将保留在未分组: ${error instanceof Error ? error.message : String(error)}`);
-                return undefined;
-            });
-        }
-        const workspace = await this.qqWorkspace;
-        if (!workspace)
-            return;
         try {
-            await workspace.attachSession(SessionId(sessionId));
+            const workspace = await registry.resolveByPath(process.cwd());
+            await workspace?.attachSession(SessionId(sessionId));
         }
         catch (error) {
-            this.logger.warn?.(`[dsh-qqchat] QQ session ${sessionId} 加入 Workspace 失败，将保留在未分组: ${error instanceof Error ? error.message : String(error)}`);
+            this.logger.warn?.(`[dsh-qqchat] QQ session ${sessionId} 未能挂载到当前工作区: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    isArchived(sessionId) {
-        const registry = this.ctx.workspaceRegistry;
-        return registry?.archivedSessionIds.includes(sessionId) ?? false;
-    }
     rememberRoute(chatType, row, agent, sessionId) {
         const provider = agent.options.provider || this.config.provider;
         const model = agent.options.model || this.config.model;
@@ -351,7 +344,7 @@ export class DshQQBridge {
             this.memory.setMemberRoute(Number(row.id), provider, model, sessionId);
     }
     appendDisplayIfMissing(session, event) {
-        if (session.events.some(item => item.type === 'qqchat/message' && item.data.messageId === event.messageId))
+        if (session.snapshotEvents().some(item => item.type === 'qqchat/message' && item.data.messageId === event.messageId))
             return;
         // Keep this on the public Session.append signature. Official DSH releases
         // do not yet expose the optional ignorable envelope marker; if an older
@@ -360,7 +353,7 @@ export class DshQQBridge {
         session.append('qqchat/message', displayEventPayload(event));
     }
     appendOwnerMessageIfMissing(session, event) {
-        if (session.events.some(item => {
+        if (session.snapshotEvents().some(item => {
             if (item.type !== 'user/message')
                 return false;
             const source = item.data.source;
@@ -541,7 +534,7 @@ export class DshQQBridge {
             const available = await presets.list();
             return { kind: 'success', text: available.length ? `可用 Agent Preset：\n${available.map(preset => `/qqpreset ${preset.id}`).join('\n')}` : '当前没有可用 Agent Preset。' };
         }
-        if (agent.session.events.some(event => event.type === 'turn/start')) {
+        if (agent.session.snapshotEvents().some(event => event.type === 'turn/start')) {
             return { kind: 'error', text: '当前 Session 已经开始对话，DSH 不允许更换 Agent Preset。请先使用 /qqnew 开启新 Session。' };
         }
         try {
@@ -559,8 +552,9 @@ export class DshQQBridge {
     }
     statusCommand(agent) {
         const current = this.selection(agent)?.current;
-        const messages = agent.session.events.filter(event => event.type === 'user/message' || event.type === 'assistant/message').length;
-        const last = agent.session.events.at(-1);
+        const events = agent.session.snapshotEvents();
+        const messages = events.filter(event => event.type === 'user/message' || event.type === 'assistant/message').length;
+        const last = events.at(-1);
         return {
             kind: 'success',
             text: ['📊 Session 状态', `Session：${String(agent.id)}`, `状态：${agent.status === 'running' ? '生成中' : '空闲'}`, `模型：${current ? `${current.provider}/${current.model}` : '未知'}`, `消息数：${messages}`, `最后事件：${last?.type || '无'}`].join('\n'),

package/lib/session/memory-snapshot.d.ts

@@ -11,6 +11,10 @@ export interface MemorySnapshotEvent {
         source?: {
             kind?: string;
             plugin?: string;
+            sections?: readonly {
+                name?: string;
+                text?: string;
+            }[];
         };
         content?: readonly {
             type?: string;

package/lib/session/memory-snapshot.js

@@ -16,9 +16,13 @@ export function restoreMemorySnapshotState(events, sourcePlugin) {
         const event = events[index];
         if (!event)
             continue;
-        if (event.type !== 'user/message' || event.data?.source?.kind !== 'plugin' || event.data.source.plugin !== sourcePlugin)
+        const source = event.data?.source;
+        if (event.type !== 'user/message' || source?.kind !== 'plugin' || source.plugin !== sourcePlugin)
             continue;
-        const block = event.data.content?.length === 1 ? event.data.content[0] : undefined;
+        if (!source.sections?.some(section => section.name === 'qq-chat-context'))
+            continue;
+        const content = event.data?.content;
+        const block = content?.length === 1 ? content[0] : undefined;
         if (block?.type !== 'text' || typeof block.text !== 'string')
             continue;
         return { hash: memorySnapshotHash(block.text), lastInjectedAt: Number(event.time) || 0, stale: lastCompactionAt > (Number(event.time) || 0) };

package/lib/session/runtime.js

@@ -28,6 +28,7 @@ export class QQChatRuntime {
         this.media = media;
     }
     async start() {
+        await this.bridge.attachMappedSessionsToWorkspace();
         for (const account of this.db.enabledAccounts())
             this.startGateway(account);
         this.outboxTimer = setInterval(() => void this.flushOutbox(), 3000);
@@ -59,6 +60,8 @@ export class QQChatRuntime {
     updateSettings(patch) {
         if (patch.memoryEnabled !== undefined)
             this.db.setSetting('memoryEnabled', Boolean(patch.memoryEnabled));
+        if (patch.memoryMemberBatchEnabled !== undefined)
+            this.db.setSetting('memoryMemberBatchEnabled', Boolean(patch.memoryMemberBatchEnabled));
         if (patch.groupReceiveMode !== undefined) {
             if (!isGroupReceiveMode(patch.groupReceiveMode))
                 throw new Error('无效的群聊接收模式');
@@ -131,8 +134,11 @@ export class QQChatRuntime {
             content: text, quotedText: '', mentioned: false, createdAt: Date.now(),
         }, row, true);
         if (this.settings().memoryEnabled) {
-            if (chatType === 'group')
+            if (chatType === 'group') {
                 this.memory.schedule(Number(row.id));
+                if (settings.memoryMemberBatchEnabled)
+                    this.memory.scheduleGroupMembers(Number(row.id));
+            }
             else
                 this.memory.scheduleMember(Number(row.id));
         }
@@ -261,10 +267,11 @@ export class QQChatRuntime {
             quotedText: message.quotedText, mentioned: message.mentioned, createdAt: Date.now(), attachments: publicAttachments(ownAttachments), quote: safeQuote,
         };
         if (settings.memoryEnabled) {
-            if (group)
+            if (group) {
                 this.memory.schedule(Number(group.id));
-            else
-                this.memory.scheduleMember(Number(member.id));
+                if (settings.memoryMemberBatchEnabled)
+                    this.memory.scheduleGroupMembers(Number(group.id));
+            }
         }
         if (!shouldReply) {
             await this.bridge.recordTranscript(displayEvent, row, true);
@@ -303,8 +310,11 @@ export class QQChatRuntime {
                 memberId: message.chatType === 'c2c' ? member.id : undefined, direction: 'outbound', content: reply, mentioned: false,
             });
             if (settings.memoryEnabled) {
-                if (group)
+                if (group) {
                     this.memory.schedule(Number(group.id));
+                    if (settings.memoryMemberBatchEnabled)
+                        this.memory.scheduleGroupMembers(Number(group.id));
+                }
                 else
                     this.memory.scheduleMember(Number(member.id));
             }

package/lib/storage/db.d.ts

@@ -1,4 +1,4 @@
-import type { AccountRow, AuthTaskRow, ChatType, DirectChatListRow, DailyEntry, GroupDefaults, GroupListRow, GroupMemberRow, GroupPatch, GroupRow, InsertMessageInput, MemberRow, MemoryDocuments, MemoryDocType, MemoryScopeType, MessageRow, OutboxRow, PublicAccountRow, QQChatRuntimeSettings, QQMediaKind, QQQuoteIndexInput, QQQuoteIndexRow, StoredAttachmentSummary } from '../types.js';
+import type { AccountRow, AuthTaskRow, ChatType, DirectChatListRow, DailyEntry, GroupDefaults, GroupListRow, GroupMemberRow, GroupPatch, GroupRow, InsertMessageInput, MemberRow, MemoryDocuments, MemoryDocType, MemoryScopeType, MessageRow, OutboxRow, PublicAccountRow, QQChatRuntimeSettings, QQMediaKind, QQQuoteIndexInput, QQQuoteIndexRow, StoredAttachmentSummary, ReflectionTaskInput } from '../types.js';
 export declare class QQChatDatabase {
     readonly path: string;
     private readonly db;
@@ -67,7 +67,12 @@ export declare class QQChatDatabase {
     recentGroupMessages(groupId: number, limit?: number): MessageRow[];
     unreflectedMessages(groupId: number, limit?: number): MessageRow[];
     unreflectedCount(groupId: number): number;
+    unreflectedMemberMessages(groupId: number, limit?: number): MessageRow[];
+    unreflectedMemberCount(groupId: number): number;
     markReflected(groupId: number, messageId: number): void;
+    markMembersReflected(groupId: number, messageId: number): void;
+    startReflectionTask(input: ReflectionTaskInput): boolean;
+    finishReflectionTask(idempotencyKey: string, status: 'completed' | 'failed'): void;
     memoryDocs(scopeType: MemoryScopeType, scopeKey: number): MemoryDocuments;
     setMemoryDoc(scopeType: MemoryScopeType, scopeKey: number, docType: MemoryDocType, content: string): void;
     appendMemoryDoc(scopeType: MemoryScopeType, scopeKey: number, docType: MemoryDocType, content: string, maxChars?: number): void;

package/lib/storage/db.js

@@ -2,6 +2,7 @@ import { DatabaseSync } from 'node:sqlite';
 import { chmodSync, mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 const now = () => Date.now();
+const REFLECTION_TASK_STALE_MS = 15 * 60 * 1000;
 function parseStringList(value) {
     if (!value)
         return [];
@@ -209,8 +210,23 @@ export class QQChatDatabase {
       CREATE TABLE IF NOT EXISTS reflection_state (
         group_id INTEGER PRIMARY KEY REFERENCES groups(id) ON DELETE CASCADE,
         last_message_id INTEGER NOT NULL DEFAULT 0,
+        last_member_reflected_message_id INTEGER NOT NULL DEFAULT 0,
         last_reflected_at INTEGER
       );
+      CREATE TABLE IF NOT EXISTS reflection_tasks (
+        id INTEGER PRIMARY KEY,
+        scope_type TEXT NOT NULL CHECK(scope_type IN ('group','member','private')),
+        scope_key INTEGER NOT NULL,
+        task_type TEXT NOT NULL CHECK(task_type IN ('group','member-batch','private-owner')),
+        start_message_id INTEGER NOT NULL,
+        end_message_id INTEGER NOT NULL,
+        status TEXT NOT NULL CHECK(status IN ('running','completed','failed')),
+        attempts INTEGER NOT NULL DEFAULT 0,
+        idempotency_key TEXT NOT NULL UNIQUE,
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS reflection_tasks_scope ON reflection_tasks(scope_type, scope_key, task_type, status);
       CREATE TABLE IF NOT EXISTS outbox (
         id INTEGER PRIMARY KEY,
         account_id INTEGER NOT NULL REFERENCES accounts(id) ON DELETE CASCADE,
@@ -223,6 +239,8 @@ export class QQChatDatabase {
         error TEXT
       );
     `);
+        this.db.prepare("UPDATE reflection_tasks SET status='failed',updated_at=? WHERE status='running' AND updated_at<?")
+            .run(now(), now() - REFLECTION_TASK_STALE_MS);
         const columns = new Set(many(this.db.prepare('PRAGMA table_info(group_members)').all()).map(column => column.name));
         const groupColumns = new Set(many(this.db.prepare('PRAGMA table_info(groups)').all()).map(column => column.name));
         if (groupColumns.has('requires_at'))
@@ -234,6 +252,10 @@ export class QQChatDatabase {
         if (!columns.has('message_count'))
             this.db.exec('ALTER TABLE group_members ADD COLUMN message_count INTEGER NOT NULL DEFAULT 0');
         const messageColumns = new Set(many(this.db.prepare('PRAGMA table_info(messages)').all()).map(column => column.name));
+        const reflectionColumns = new Set(many(this.db.prepare('PRAGMA table_info(reflection_state)').all()).map(column => column.name));
+        if (!reflectionColumns.has('last_member_reflected_message_id')) {
+            this.db.exec('ALTER TABLE reflection_state ADD COLUMN last_member_reflected_message_id INTEGER NOT NULL DEFAULT 0');
+        }
         if (!messageColumns.has('attachments_json'))
             this.db.exec('ALTER TABLE messages ADD COLUMN attachments_json TEXT');
         if (!messageColumns.has('quote_json'))
@@ -342,6 +364,7 @@ export class QQChatDatabase {
     runtimeSettings(defaults) {
         return {
             memoryEnabled: this.getSetting('memoryEnabled', defaults.memoryEnabled),
+            memoryMemberBatchEnabled: this.getSetting('memoryMemberBatchEnabled', defaults.memoryMemberBatchEnabled),
             groupReceiveMode: this.getSetting('groupReceiveMode', defaults.groupReceiveMode),
             groupReplyFormat: this.getSetting('groupReplyFormat', defaults.groupReplyFormat),
             directReplyFormat: this.getSetting('directReplyFormat', this.getSetting('replyFormat', defaults.directReplyFormat)),
@@ -611,11 +634,45 @@ export class QQChatDatabase {
         const row = one(this.db.prepare('SELECT COUNT(*) AS n FROM messages WHERE group_id=? AND id>?').get(groupId, Number(state?.last_message_id || 0)));
         return Number(row?.n || 0);
     }
+    unreflectedMemberMessages(groupId, limit = 80) {
+        const state = one(this.db.prepare('SELECT last_member_reflected_message_id FROM reflection_state WHERE group_id=?').get(groupId));
+        const after = Number(state?.last_member_reflected_message_id || 0);
+        return many(this.db.prepare(`SELECT m.*,mem.platform_user_id,mem.display_name
+      FROM messages m LEFT JOIN members mem ON mem.id=m.member_id
+      WHERE m.group_id=? AND m.id>? ORDER BY m.id ASC LIMIT ?`).all(groupId, after, limit));
+    }
+    unreflectedMemberCount(groupId) {
+        const state = one(this.db.prepare('SELECT last_member_reflected_message_id FROM reflection_state WHERE group_id=?').get(groupId));
+        const row = one(this.db.prepare('SELECT COUNT(*) AS n FROM messages WHERE group_id=? AND id>?').get(groupId, Number(state?.last_member_reflected_message_id || 0)));
+        return Number(row?.n || 0);
+    }
     markReflected(groupId, messageId) {
         this.db.prepare(`INSERT INTO reflection_state(group_id,last_message_id,last_reflected_at) VALUES(?,?,?)
       ON CONFLICT(group_id) DO UPDATE SET last_message_id=excluded.last_message_id,last_reflected_at=excluded.last_reflected_at`)
             .run(groupId, messageId, now());
     }
+    markMembersReflected(groupId, messageId) {
+        this.db.prepare(`INSERT INTO reflection_state(group_id,last_message_id,last_member_reflected_message_id,last_reflected_at) VALUES(?,?,?,?)
+      ON CONFLICT(group_id) DO UPDATE SET last_member_reflected_message_id=excluded.last_member_reflected_message_id,last_reflected_at=excluded.last_reflected_at`)
+            .run(groupId, 0, messageId, now());
+    }
+    startReflectionTask(input) {
+        const existing = one(this.db.prepare('SELECT id,status FROM reflection_tasks WHERE idempotency_key=?').get(input.idempotencyKey));
+        if (existing?.status === 'completed' || existing?.status === 'running')
+            return false;
+        if (existing) {
+            this.db.prepare(`UPDATE reflection_tasks SET status='running',attempts=attempts+1,updated_at=? WHERE id=?`)
+                .run(now(), existing.id);
+            return true;
+        }
+        this.db.prepare(`INSERT INTO reflection_tasks(scope_type,scope_key,task_type,start_message_id,end_message_id,status,attempts,idempotency_key,created_at,updated_at)
+      VALUES(?,?,?,?,?,'running',1,?,?,?)`)
+            .run(input.scopeType, input.scopeKey, input.taskType, input.startMessageId, input.endMessageId, input.idempotencyKey, now(), now());
+        return true;
+    }
+    finishReflectionTask(idempotencyKey, status) {
+        this.db.prepare('UPDATE reflection_tasks SET status=?,updated_at=? WHERE idempotency_key=?').run(status, now(), idempotencyKey);
+    }
     memoryDocs(scopeType, scopeKey) {
         const rows = many(this.db.prepare('SELECT doc_type,content,updated_at FROM memory_documents WHERE scope_type=? AND scope_key=?')
             .all(scopeType, scopeKey));

package/lib/storage/memory.d.ts

@@ -1,13 +1,19 @@
 import type { Context } from '@deepseek-ai/cordis';
 import type { QQChatDatabase } from './db.js';
-import type { GroupRow, LoggerLike, MemoryDocuments, MemoryView, QQChatConfig, ReflectionPayload, QQNormalizedMessage } from '../types.js';
+import type { GroupRow, LoggerLike, MemoryDocuments, MemoryView, QQChatConfig, ReflectionPayload, MemberBatchReflectionPayload, QQNormalizedMessage } from '../types.js';
 interface MemberReflectionPayload {
+    profile_add?: unknown;
+    profile_remove?: unknown;
+    pattern_add?: unknown;
+    pattern_remove?: unknown;
     profile?: unknown;
     pattern?: unknown;
     summary?: unknown;
     memory?: unknown;
     daily?: unknown;
 }
+/** 与咕咕一致：每个记忆 scope 的本轮直注入预算（按字符计）。 */
+export declare const MEMORY_INJECT_CHARS = 2000;
 export declare class MemoryEngine {
     private readonly ctx;
     private readonly db;
@@ -15,24 +21,38 @@ export declare class MemoryEngine {
     private readonly logger;
     private readonly timers;
     private readonly memberTimers;
+    private readonly memberBatchTimers;
     private readonly routes;
     private readonly memberRoutes;
     private readonly reflectingGroups;
     private readonly reflectingMembers;
+    private readonly reflectingMemberBatches;
+    private readonly groupRetryAt;
+    private readonly memberRetryAt;
+    private readonly memberBatchRetryAt;
     constructor(ctx: Context, db: QQChatDatabase, config: QQChatConfig, logger?: LoggerLike);
     dispose(): void;
     setRoute(groupId: number, provider: string, model: string, sessionId: string): void;
     setMemberRoute(memberId: number, provider: string, model: string, sessionId: string): void;
     schedule(groupId: number): void;
     scheduleMember(memberId: number): void;
+    scheduleGroupMembers(groupId: number): void;
+    private inRetryCooldown;
+    private reflectionDelay;
+    private runScheduledGroupReflection;
+    private runScheduledMemberReflection;
+    private runScheduledMemberBatchReflection;
     reflectNow(groupId: number): Promise<MemoryView>;
     private reflectNowInternal;
+    reflectMembersNow(groupId: number): Promise<MemoryView>;
+    private reflectMembersNowInternal;
     reflectMemberNow(memberId: number): Promise<MemoryDocuments>;
     private reflectMemberNowInternal;
     private compactDaily;
     private generateReflection;
     private unreflectedDirectMessages;
-    private applyReflection;
+    private applyGroupReflection;
+    private applyMemberBatchReflection;
     contextForGroup(group: GroupRow, currentMember?: {
         id: number;
         platform_user_id: string;
@@ -46,5 +66,11 @@ export declare class MemoryEngine {
     currentMessageText(message: QQNormalizedMessage): string;
     memoryView(groupId: number): MemoryView | undefined;
 }
+export declare function memorySystemPrompt(): string;
+export declare function memberBatchMemorySystemPrompt(): string;
+export declare function privateMemorySystemPrompt(): string;
+export declare function groupCompressionSystemPrompt(): string;
+export declare function memberCompressionSystemPrompt(): string;
 export declare function parseJsonObject(text: string): ReflectionPayload | MemberReflectionPayload;
+export declare function validateMemberBatchPayload(value: unknown, allowedSenderIds: ReadonlySet<string>): value is MemberBatchReflectionPayload;
 export {};