dsh-world 0.6.4 → 0.6.5

package/lib/ecosystem/wechat/stickerLibrary.d.ts

@@ -0,0 +1,50 @@
+export type StickerMediaType = 'image/gif' | 'image/png' | 'image/webp' | 'image/jpeg';
+/** `file` lives under `files/` beside the index; the adapter reads both when it sends. */
+export interface Sticker {
+    id: string;
+    name: string;
+    tags: string[];
+    file: string;
+    mediaType: StickerMediaType;
+    md5: string;
+    bytes: number;
+    addedAt: number;
+}
+export interface StickerLabels {
+    name?: string;
+    tags?: string[];
+}
+export declare const MAX_STICKERS = 500;
+export declare const MAX_STICKER_BYTES: number;
+/** The world's own sticker library: a folder with `index.json` and the image files, written atomically and one change at a time. */
+export declare function createStickerLibrary(dir: string): {
+    dir: string;
+    list: () => Promise<Sticker[]>;
+    has(id: string): Promise<boolean>;
+    /** `existing`: the same image was already in the library, so nothing changed. `id` is only for importing an older library. */
+    add: (data: Buffer, labels: StickerLabels & {
+        id?: string;
+    }, options?: {
+        expectedMd5?: string;
+    }) => Promise<{
+        sticker: Sticker;
+        existing: boolean;
+    }>;
+    edit: (id: string, labels: StickerLabels) => Promise<Sticker>;
+    remove: (id: string) => Promise<void>;
+    /** A few best matches, newest first among equals; a query matches the name and tags, any word counting once. */
+    search(input: {
+        query?: string;
+        limit?: number;
+    }): Promise<{
+        total: number;
+        items: Sticker[];
+    }>;
+};
+export type StickerLibrary = ReturnType<typeof createStickerLibrary>;
+/** One-time import of the older sticker plugin's folder (`catalog.json` + `assets/`): ids, names and tags carry over, packs and long meanings do not. */
+export declare function importLegacyStickers(legacyDir: string, library: StickerLibrary): Promise<{
+    imported: number;
+    duplicates: number;
+    skipped: string[];
+}>;

package/lib/ecosystem/wechat/stickerLibrary.js

@@ -0,0 +1,167 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, rename, rm, writeFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+export const MAX_STICKERS = 500;
+export const MAX_STICKER_BYTES = 10 * 1024 * 1024;
+const EXTENSION = { 'image/gif': 'gif', 'image/png': 'png', 'image/webp': 'webp', 'image/jpeg': 'jpg' };
+const idPattern = /^st_[A-Za-z0-9_-]{4,40}$/;
+const control = /[\u0000-\u001f\u007f]/;
+const length = (text) => [...text].length;
+function mediaTypeOf(data) {
+    if (data.length > 12) {
+        if (data.subarray(0, 6).toString('latin1') === 'GIF87a' || data.subarray(0, 6).toString('latin1') === 'GIF89a')
+            return 'image/gif';
+        if (data.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])))
+            return 'image/png';
+        if (data.subarray(0, 4).toString('latin1') === 'RIFF' && data.subarray(8, 12).toString('latin1') === 'WEBP')
+            return 'image/webp';
+        if (data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff)
+            return 'image/jpeg';
+    }
+    throw new Error('表情包需要是 GIF、PNG、WebP 或 JPEG 图片');
+}
+function cleanName(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || !value.trim() || length(value.trim()) > 30 || control.test(value))
+        throw new Error('名称最长 30 字，不能含控制字符');
+    return value.trim();
+}
+function cleanTags(value) {
+    const tags = Array.isArray(value) ? value : [];
+    const clean = [...new Set(tags.map(tag => typeof tag === 'string' ? tag.trim() : tag))];
+    if (!clean.length || clean.length > 8 || clean.some(tag => typeof tag !== 'string' || !tag || length(tag) > 16 || control.test(tag)))
+        throw new Error('标签需要 1–8 个，每个 1–16 字');
+    return clean;
+}
+function parseIndex(text) {
+    const value = JSON.parse(text);
+    if (value.version !== 1 || !Array.isArray(value.stickers))
+        throw new Error('结构不正确');
+    for (const entry of value.stickers) {
+        if (!entry || typeof entry.id !== 'string' || !idPattern.test(entry.id) || typeof entry.name !== 'string' || !Array.isArray(entry.tags)
+            || typeof entry.file !== 'string' || basename(entry.file) !== entry.file || !(entry.mediaType in EXTENSION)
+            || typeof entry.md5 !== 'string' || !/^[a-f0-9]{32}$/.test(entry.md5) || !Number.isSafeInteger(entry.bytes) || !Number.isFinite(entry.addedAt))
+            throw new Error(`条目 ${String(entry?.id)} 不正确`);
+    }
+    return value.stickers;
+}
+/** The world's own sticker library: a folder with `index.json` and the image files, written atomically and one change at a time. */
+export function createStickerLibrary(dir) {
+    const indexFile = join(dir, 'index.json'), filesDir = join(dir, 'files');
+    let chain = Promise.resolve();
+    const serial = (job) => { const next = chain.then(job); chain = next.catch(() => undefined); return next; };
+    async function read() {
+        let text;
+        try {
+            text = await readFile(indexFile, 'utf8');
+        }
+        catch (error) {
+            if (error.code === 'ENOENT')
+                return [];
+            throw error;
+        }
+        try {
+            return parseIndex(text);
+        }
+        catch (error) {
+            throw new Error(`表情库索引 index.json 无法读取（${error.message}），已保留原文件等待人工修复`);
+        }
+    }
+    async function write(stickers) {
+        await mkdir(dir, { recursive: true });
+        const temporary = `${indexFile}.tmp`;
+        await writeFile(temporary, JSON.stringify({ version: 1, stickers }, null, 2), 'utf8');
+        await rename(temporary, indexFile);
+    }
+    const find = (stickers, id) => {
+        const sticker = stickers.find(entry => entry.id === id);
+        if (!sticker)
+            throw new Error(`没有这个表情：${id}`);
+        return sticker;
+    };
+    return {
+        dir,
+        list: () => serial(read),
+        async has(id) { return (await serial(read)).some(sticker => sticker.id === id); },
+        /** `existing`: the same image was already in the library, so nothing changed. `id` is only for importing an older library. */
+        add: (data, labels, options = {}) => serial(async () => {
+            if (data.length > MAX_STICKER_BYTES)
+                throw new Error('表情包超过 10MB，过大');
+            const mediaType = mediaTypeOf(data);
+            const md5 = createHash('md5').update(data).digest('hex');
+            if (options.expectedMd5 !== undefined && options.expectedMd5 !== md5)
+                throw new Error('下载内容的 md5 与核对时不一致，已丢弃');
+            const tags = cleanTags(labels.tags), name = cleanName(labels.name) ?? tags[0];
+            const stickers = await read();
+            const same = stickers.find(entry => entry.md5 === md5);
+            if (same)
+                return { sticker: same, existing: true };
+            if (stickers.length >= MAX_STICKERS)
+                throw new Error(`表情库已满（最多 ${MAX_STICKERS} 张），先移除一些再收`);
+            const id = labels.id ?? `st_${md5.slice(0, stickers.some(entry => entry.id === `st_${md5.slice(0, 12)}`) ? 20 : 12)}`;
+            if (!idPattern.test(id) || stickers.some(entry => entry.id === id))
+                throw new Error(`表情 ID 无效或已被另一张图片使用：${id}`);
+            const sticker = { id, name, tags, file: `${id}.${EXTENSION[mediaType]}`, mediaType, md5, bytes: data.length, addedAt: Date.now() };
+            await mkdir(filesDir, { recursive: true });
+            await writeFile(join(filesDir, sticker.file), data);
+            try {
+                await write([...stickers, sticker]);
+            }
+            catch (error) {
+                await rm(join(filesDir, sticker.file), { force: true });
+                throw error;
+            }
+            return { sticker, existing: false };
+        }),
+        edit: (id, labels) => serial(async () => {
+            const stickers = await read();
+            const sticker = find(stickers, id);
+            const next = { ...sticker, ...(labels.name === undefined ? {} : { name: cleanName(labels.name) }), ...(labels.tags === undefined ? {} : { tags: cleanTags(labels.tags) }) };
+            await write(stickers.map(entry => entry === sticker ? next : entry));
+            return next;
+        }),
+        remove: (id) => serial(async () => {
+            const stickers = await read();
+            const sticker = find(stickers, id);
+            await write(stickers.filter(entry => entry !== sticker));
+            await rm(join(filesDir, sticker.file), { force: true });
+        }),
+        /** A few best matches, newest first among equals; a query matches the name and tags, any word counting once. */
+        async search(input) {
+            const stickers = await serial(read);
+            const words = (input.query ?? '').toLowerCase().split(/[\s,，、/;；]+/).filter(Boolean);
+            const limit = Math.min(Math.max(Number.isSafeInteger(input.limit) ? input.limit : 8, 1), 20);
+            const scored = [...stickers].reverse().map(sticker => {
+                const text = [sticker.name, ...sticker.tags].join('\n').toLowerCase();
+                return { sticker, score: words.filter(word => text.includes(word)).length };
+            }).filter(entry => !words.length || entry.score > 0);
+            scored.sort((a, b) => b.score - a.score);
+            return { total: stickers.length, items: scored.slice(0, limit).map(entry => entry.sticker) };
+        },
+    };
+}
+/** One-time import of the older sticker plugin's folder (`catalog.json` + `assets/`): ids, names and tags carry over, packs and long meanings do not. */
+export async function importLegacyStickers(legacyDir, library) {
+    const catalog = JSON.parse(await readFile(join(legacyDir, 'catalog.json'), 'utf8'));
+    const report = { imported: 0, duplicates: 0, skipped: [] };
+    for (const pack of catalog.packs ?? [])
+        for (const entry of pack.stickers ?? []) {
+            try {
+                if (typeof entry.id !== 'string' || typeof entry.file !== 'string' || basename(entry.file) !== entry.file)
+                    throw new Error('条目不完整');
+                const name = [...String(entry.name ?? '').trim()].slice(0, 30).join('') || undefined;
+                const tags = [...new Set((entry.tags ?? []).map(tag => [...String(tag).trim()].slice(0, 16).join('')).filter(Boolean))].slice(0, 8);
+                const data = await readFile(join(legacyDir, 'assets', entry.file));
+                const result = await library.add(data, { id: entry.id, ...(name ? { name } : {}), tags: tags.length ? tags : [name ?? '表情'] });
+                if (result.existing)
+                    report.duplicates++;
+                else
+                    report.imported++;
+            }
+            catch (error) {
+                report.skipped.push(`${String(entry?.id)}：${error.message}`);
+            }
+        }
+    return report;
+}

package/lib/ecosystem/wechat/stickerTools.d.ts

@@ -0,0 +1,18 @@
+import { type ToolRunContext } from '@deepseek-ai/dsh-tools';
+import type { SpeakerIdentity } from '../shared/identity.ts';
+import type { StickerLibrary } from './stickerLibrary.ts';
+/**
+ * The model's side of the world's own sticker library. Kept deliberately small: nothing here puts a catalog or a
+ * picture in front of the model unless it asked, and sending is the ordinary `wechat_send`.
+ */
+export declare function createStickerTools(deps: {
+    library: StickerLibrary;
+    /** Where the adapter leaves a fetched original until the library has taken it. */
+    stagingDir: string;
+    target(chatId: string): SpeakerIdentity;
+    ask(identity: SpeakerIdentity, fields: {
+        chatId: string;
+        limit: number;
+        stickerId: string;
+    }, context: ToolRunContext): Promise<string>;
+}): import("@deepseek-ai/dsh-tools").ToolDefinition[];

package/lib/ecosystem/wechat/stickerTools.js

@@ -0,0 +1,69 @@
+import { readFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { defineTool } from '@deepseek-ai/dsh-tools';
+import { wechatTextOutput } from "./messages.js";
+const messageIdPattern = /^[A-Za-z0-9_.-]{1,64}:\d{1,20}$/;
+const labels = (tags) => tags.join('/');
+/**
+ * The model's side of the world's own sticker library. Kept deliberately small: nothing here puts a catalog or a
+ * picture in front of the model unless it asked, and sending is the ordinary `wechat_send`.
+ */
+export function createStickerTools(deps) {
+    const { library } = deps;
+    return [
+        defineTool({
+            name: 'sticker_search',
+            description: '按关键词查表情库（匹配名称、标签），返回 id｜名称｜标签；不带词看最近收的，limit 默认 8、最多 20。发送用 wechat_send 的 {type:"sticker", stickerId}。',
+            parameters: { query: { type: 'string' }, limit: { type: 'integer' } },
+            output: wechatTextOutput,
+            execute: async ({ query, limit }) => {
+                const { total, items } = await library.search({ ...(query === undefined ? {} : { query }), ...(limit === undefined ? {} : { limit }) });
+                if (!total)
+                    return '表情库还是空的，可以用 sticker_save 收别人发来的表情包。';
+                if (!items.length)
+                    return `没有匹配「${query ?? ''}」的表情（库里共 ${total} 张）。换个词，或不带关键词看最近收的。`;
+                return `共 ${total} 张，显示 ${items.length} 张：\n` + items.map(sticker => `${sticker.id}｜${sticker.name}｜${labels(sticker.tags)}`).join('\n');
+            },
+        }),
+        defineTool({
+            name: 'sticker_save',
+            description: '把聊天里别人发来的表情包收进库。chatId、messageId 取自那条消息；tags 1–8 个短词（每个≤16 字）概括情绪和用法；name 可省。同一张图不重复收。',
+            parameters: { chatId: { type: 'string', required: true }, messageId: { type: 'string', required: true }, tags: { type: 'array', items: { type: 'string' }, required: true }, name: { type: 'string' } },
+            output: wechatTextOutput,
+            execute: async ({ chatId, messageId, tags, name }, context) => {
+                if (!messageIdPattern.test(messageId))
+                    throw new Error('messageId 必须是那条表情消息的 id');
+                const identity = deps.target(chatId);
+                const staged = JSON.parse(await deps.ask(identity, { chatId, limit: 1, stickerId: messageId }, context));
+                const file = join(deps.stagingDir, staged.file);
+                try {
+                    context.signal.throwIfAborted();
+                    const { sticker, existing } = await library.add(await readFile(file), { tags, ...(name === undefined ? {} : { name }) }, { expectedMd5: staged.md5 });
+                    return existing ? `库里已经有这张：${sticker.id}「${sticker.name}」（标签 ${labels(sticker.tags)}，没有改动）。` : `已收进表情库：${sticker.id}「${sticker.name}」（标签 ${labels(sticker.tags)}）。`;
+                }
+                finally {
+                    await rm(file, { force: true });
+                }
+            },
+        }),
+        defineTool({
+            name: 'sticker_edit',
+            description: '改表情的名称或标签（tags 整个替换）。',
+            parameters: { id: { type: 'string', required: true }, name: { type: 'string' }, tags: { type: 'array', items: { type: 'string' } } },
+            output: wechatTextOutput,
+            execute: async ({ id, name, tags }) => {
+                if (name === undefined && tags === undefined)
+                    throw new Error('需要给出新的 name 或 tags');
+                const sticker = await library.edit(id, { ...(name === undefined ? {} : { name }), ...(tags === undefined ? {} : { tags }) });
+                return `已更新 ${sticker.id}「${sticker.name}」：${labels(sticker.tags)}`;
+            },
+        }),
+        defineTool({
+            name: 'sticker_remove',
+            description: '删除表情及其图片文件。',
+            parameters: { id: { type: 'string', required: true } },
+            output: wechatTextOutput,
+            execute: async ({ id }) => { await library.remove(id); return `已移出 ${id}。`; },
+        }),
+    ];
+}

package/lib/index.d.ts

@@ -6,7 +6,7 @@ export type { WorldConfig, ConversationRecord, ConversationTurn, ArchiveCursor }
 export declare const name = "dsh-world";
 export declare const inject: string[];
 /** What `apply` receives: the schema below fills these defaults. */
-export type Config = WorldConfig & Required<Pick<WorldConfig, 'life' | 'fallbackWakeTime' | 'outlets' | 'bridge' | 'toast' | 'allowedHosts'>>;
+export type Config = WorldConfig & Required<Pick<WorldConfig, 'life' | 'replaceCompaction' | 'fallbackWakeTime' | 'outlets' | 'bridge' | 'toast' | 'allowedHosts'>>;
 export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     worldId: z<string, string, "defined">;
     agentPreset: z<string, string, "defined">;
@@ -14,6 +14,7 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     companionName: z<string, string, "plain">;
     partnerName: z<string, string, "plain">;
     archiveScope: z<"home" | "workspace" | "world", "home" | "workspace", "defined">;
+    replaceCompaction: z<boolean, boolean, "defined">;
     life: z<boolean, boolean, "defined">;
     diaryDir: z<string, string, "plain">;
     fallbackWakeTime: z<string, string, "defined">;
@@ -108,6 +109,7 @@ export declare const Config: z<Schemastery.ObjectS<NoInfer<{
     companionName: z<string, string, "plain">;
     partnerName: z<string, string, "plain">;
     archiveScope: z<"home" | "workspace" | "world", "home" | "workspace", "defined">;
+    replaceCompaction: z<boolean, boolean, "defined">;
     life: z<boolean, boolean, "defined">;
     diaryDir: z<string, string, "plain">;
     fallbackWakeTime: z<string, string, "defined">;

package/lib/index.js

@@ -8,6 +8,7 @@ import { consoleRoute } from "./console/routes.js";
 import { consoleSources } from "./console/snapshot.js";
 import { createHomeApply } from "./console/homeApply.js";
 import { errorText, Faults } from "./faults.js";
+import { swapCompactionOnce } from "./compactionSwap.js";
 import { hostLife } from "./life/host.js";
 import { createLifeStore, durableWrite } from "./life/lifeStore.js";
 import { toastSupported, windowsToast } from "./life/notify.js";
@@ -39,6 +40,8 @@ export const Config = z.object({
     worldId: z.string().default('default'), agentPreset: z.string().default('standard'), timeZone: z.string().default(systemTimeZone),
     companionName: z.string(), partnerName: z.string(),
     archiveScope: z.union([z.const('home').description('仅家会话'), z.const('workspace').description('家所在工作区'), z.transform(z.const('world').hidden(), () => 'workspace').hidden()]).default('workspace').description('记忆归档范围，修改后重启生效'),
+    // Install means the tool-free compaction: the first start rewrites the profile's stock compaction row (see README); false leaves it alone.
+    replaceCompaction: z.boolean().default(true),
     life: z.boolean().default(true), diaryDir: z.string(), fallbackWakeTime: z.string().pattern(/^([01]\d|2[0-3]):[0-5]\d$/).default('09:00'),
     selfFile: z.string(), worldPromptFile: z.string(), alarmTemplateFile: z.string(), personaFile: z.string(),
     // Where her words go outside DSH; no app is known by name (see README for the push body).
@@ -169,6 +172,8 @@ export async function apply(ctx, config) {
     ctx.inject(['sessionController', 'permissionPresets', 'webServer'], async (lifeCtx) => {
         const webServer = lifeCtx.webServer;
         const host = hostLife(lifeCtx);
+        swapCompactionOnce({ enabled: config.replaceCompaction, profileDir: lifeCtx.get('profileContext')?.dir, done: power.compactionSwapped, markDone: power.markCompactionSwapped,
+            report: message => { faults.set('compaction-swap', message); lifeCtx.logger.warn(`dsh-world: ${message}`); } });
         const permissions = createWorkspacePermissions(lifeCtx, options.roomDir, power);
         // QQ 的两扇门：她自己那条 OneBot 通道的状态与开关，以及 SnowLuma 的控制台。**无条件注册** —— 通道
         // 关着的时候 /native 回 null，而 SnowLuma 那扇门跟通道没关系。（这里原来还有一半是给外面那个
@@ -308,7 +313,8 @@ export async function apply(ctx, config) {
                 await lifeStop;
                 const outlets = config.outlets.map(outlet => createOutlet(outlet, () => host.origin()));
                 const notifier = { ...(config.toast && toastSupported() ? { toast: windowsToast(config.toastAppId || undefined) } : {}), outlets };
-                const current = createLifeRuntime({ ctx: lifeCtx, config: { ...config, companionName: names().companion }, options, store: lifeStore, host, notifier, dailyBudget: power.dailyBudget, inWorkspace, photos, alarmContext: now => wechat?.presence(now) });
+                const current = createLifeRuntime({ ctx: lifeCtx, config: { ...config, companionName: names().companion }, options, store: lifeStore, host, notifier, dailyBudget: power.dailyBudget, inWorkspace, photos, alarmContext: now => wechat?.presence(now), afterReview: () => { if (power.compactAfterReview())
+                        homeApply.request(); } });
                 life = current;
                 isHome = current.isHome;
                 if (config.bridge) {
@@ -345,7 +351,7 @@ export async function apply(ctx, config) {
         if (config.bridge)
             lifeCtx.effect(() => webServer.register(bridgeRoute(() => bridge, config.allowedHosts)), 'dsh-world bridge route');
         // Her album lives in her room, so the console shows it whether or not the life line is running.
-        const sources = consoleSources({ ctx: lifeCtx, config: memoryConfig, archive: store, names, ...(lifeStore ? { lifeStore } : {}), life: () => life, homeApply: homeApply.snapshot, photos, diaryDir: options.diaryDir, running: power.running, dailyBudget: power.dailyBudget, memoryTurns: power.memoryTurns, selectedArchiveScope: power.selectedArchiveScope, workspacePermissions: permissions.snapshot, wechat: () => wechat ? { ...wechat.status(), adapter: adapter?.status() ?? null } : undefined, archiveSession, native: () => qqNative?.status() ?? null,
+        const sources = consoleSources({ ctx: lifeCtx, config: memoryConfig, archive: store, names, ...(lifeStore ? { lifeStore } : {}), life: () => life, homeApply: homeApply.snapshot, compactAfterReview: power.compactAfterReview, photos, diaryDir: options.diaryDir, running: power.running, dailyBudget: power.dailyBudget, memoryTurns: power.memoryTurns, selectedArchiveScope: power.selectedArchiveScope, workspacePermissions: permissions.snapshot, wechat: () => wechat ? { ...wechat.status(), adapter: adapter?.status() ?? null } : undefined, archiveSession, native: () => qqNative?.status() ?? null,
             modules: () => ({ wechat: { available: config.wechat, enabled: power.wechatEnabled(), running: wechat !== undefined }, qq: { available: Boolean(config.qqNative?.enabled), enabled: power.qqEnabled(), running: qqNative !== undefined, ...(qqSdk.needsRestart() ? { restartRequired: true } : {}) } }), faults: () => [...faults.list(), ...(memory?.faults() ?? []), ...(bridge?.faults() ?? [])] });
         const actions = {
             async start() {
@@ -381,6 +387,7 @@ export async function apply(ctx, config) {
             setDailyBudget: yuan => { power.setDailyBudget(yuan); sources.invalidate(); },
             setMemoryTurns: turns => { power.setMemoryTurns(turns); sources.invalidate(); },
             setWorkspacePermission: permission => { permissions.set(permission); sources.invalidate(); },
+            setCompactAfterReview: on => { power.setCompactAfterReview(on); sources.invalidate(); },
             async setModules(patch) {
                 if (patch.wechat !== undefined && !config.wechat)
                     return '没有配置微信模块（配置里 wechat: true）';

package/lib/life/activity.js

@@ -28,6 +28,11 @@ const spoken = {
     wechat_chats: () => '看了看微信能发给谁',
     wechat_delivery: () => '查了一条微信送到没有',
     wechat_history: () => '翻了翻微信的聊天记录',
+    wechat_image: () => '看了一张微信群里的图片',
+    sticker_search: () => '翻了翻表情库',
+    sticker_save: () => '把一个表情包收进了表情库',
+    sticker_edit: () => '改了改表情库里的表情',
+    sticker_remove: () => '整理了一下表情库',
     send_sticker: () => '发了个表情',
     web_search: (args) => {
         const queries = args.queries;

package/lib/life/runtime.d.ts

@@ -19,6 +19,8 @@ export interface LifeDeps {
     timers?: LifeTimers;
     /** CNY her home may spend a day; undefined or absent is no limit. */
     dailyBudget?: () => number | undefined;
+    /** Called once each evening look back has been handed to her home (not for alarms or greetings, and not when delivery failed). */
+    afterReview?: () => void;
     /** Read-only facts appended after the user's alarm template is rendered. */
     alarmContext?: (now: Date) => string | undefined;
     photos?: () => PhotoStore;

package/lib/life/runtime.js

@@ -229,7 +229,7 @@ export function createLifeRuntime(deps) {
      * A message of the plugin's own, taken off the schedule while it is sent and put back if it fails: it backs
      * off like an alarm, and its turn is never asked about as an early stop. It counts once its turn starts a step.
      */
-    async function sayOwn(what, source, scheduledAt, job, take, putBack, text) {
+    async function sayOwn(what, source, scheduledAt, job, take, putBack, text, delivered) {
         try {
             const agent = await home.open();
             if (stopped)
@@ -240,6 +240,8 @@ export function createLifeRuntime(deps) {
             expect(agent, message, what, scheduledAt, source, job, now);
             earlyStop.startsOwnTurn();
             await say(agent, message);
+            if (!stopped)
+                delivered?.();
         }
         catch (error) {
             ctx.logger.error(error);
@@ -280,7 +282,7 @@ export function createLifeRuntime(deps) {
         return sayOwn('每日回顾', 'review', review.at, { review }, take, () => { state.review = review; }, now => reviewText(review, now, {
             ...withValue('conversations', existing('conversations')), ...withValue('activity', existing('activity')), ...withValue('snapshot', snapshot),
             diaryDir: options.diaryDir, selfFile: options.selfFile,
-        }, timeZone, options.fallbackWakeTime, alarmMessages(), templateValues()));
+        }, timeZone, options.fallbackWakeTime, alarmMessages(), templateValues()), () => deps.afterReview?.());
     }
     async function send(alarm) {
         try {

package/lib/runtime.js

@@ -46,11 +46,9 @@ export function createWorldRuntime(ctx, config, store, world, memoryTurns = () =
         const event = session.eventAt(seq);
         return event?.type === 'user/message' && event.data.source.kind === memorySource;
     });
-    /** Locate earlier memory blocks; every runtime start rebuilds from the active scope and real times. */
+    /** Restore the loop position; recalled blocks are located directly on the current surface. */
     async function readMemoryState(session) {
-        const injected = new Map();
         let position = { turn: 1, step: 1 };
-        const surface = new Set(session.surface.nodes);
         const handle = await ctx.sessionPersistence.open(session.id, 'read');
         try {
             for (let offset = 0;; offset += 128) {
@@ -60,9 +58,6 @@ export function createWorldRuntime(ctx, config, store, world, memoryTurns = () =
                 for (const event of events) {
                     if (event.type === 'step/start')
                         position = { turn: event.data.turn, step: event.data.step };
-                    const block = event.type === 'user/message' && event.data.source.kind === memorySource;
-                    if (block && surface.has(event.seq))
-                        injected.set(event.data.id, event.seq);
                 }
             }
         }
@@ -70,20 +65,33 @@ export function createWorldRuntime(ctx, config, store, world, memoryTurns = () =
             await handle.close();
         }
         const inScope = included(session);
-        return { reload: true, injected, position, inScope, restart: !inScope && belongsToWorld(session, config) };
+        return { reload: true, position, retiring: [], inScope, restart: !inScope && belongsToWorld(session, config) };
     }
-    /** Empty system nodes retire only our recalled blocks and derive no model message; original logs stay intact. */
+    /**
+     * Marks our recalled blocks on the surface for retirement. The empty system node that retires one is accepted by
+     * the host only inside an open turn and step, which pre-step and attach are not, so `flushRetired` writes it from
+     * the step's request hook, after the step has started and before the request is assembled (#22).
+     */
     function retireMemory(session, state) {
-        for (const [id, seq] of state.injected) {
-            if (session.surface.nodes.includes(seq)) {
-                session.append('system/message', { ...state.position, message: createSystemMessage('') }, { surfaceOp: { op: 'replace', startSeq: seq, endSeq: seq }, sourceEventSeqs: [seq] });
-                state.restart = true;
-            }
-            state.injected.delete(id);
-        }
+        state.retiring = session.surface.nodes.filter(seq => {
+            const event = session.eventAt(seq);
+            return event?.type === 'user/message' && event.data.source.kind === memorySource;
+        });
+        if (state.retiring.length)
+            state.restart = true;
         state.reload = true;
         state.pendingId = undefined;
     }
+    /** Empty system nodes retire only our recalled blocks and derive no model message; original logs stay intact. */
+    function flushRetired(session, state, position) {
+        const retiring = state.retiring;
+        state.retiring = [];
+        for (const seq of retiring) {
+            if (!session.surface.nodes.includes(seq))
+                continue;
+            session.append('system/message', { ...position, message: createSystemMessage('') }, { surfaceOp: { op: 'replace', startSeq: seq, endSeq: seq }, sourceEventSeqs: [seq] });
+        }
+    }
     async function attach(agent) {
         const { session } = agent;
         if (memory.has(session) || !mayCarryWorld(session))
@@ -98,9 +106,9 @@ export function createWorldRuntime(ctx, config, store, world, memoryTurns = () =
                 await archive.schedule(session.id);
             }
             const state = await readMemoryState(session);
+            // Retiring writes a system/message, which the host only accepts inside an open turn and step; attach runs
+            // between turns, so an out-of-scope block is retired by the next pre-step (before any request) instead (#22).
             memory.set(session, state);
-            if (!included(session))
-                retireMemory(session, state);
         });
         attaching.set(session, job);
         try {
@@ -110,31 +118,16 @@ export function createWorldRuntime(ctx, config, store, world, memoryTurns = () =
             attaching.delete(session);
         }
     }
-    /** Retires the blocks still on the surface (they must be found, or the session would carry two) and builds a fresh one without the messages already present. */
+    /** Retire old blocks, then admit fresh memory through the host's normal append path (#21). */
     async function freshBlock(session, state) {
-        const messages = session.deriveMessages();
         const turns = await history.loadRecentTurns(config.worldId, memoryTurns(), archivedByScope);
         if (!included(session)) {
             retireMemory(session, state);
             return undefined;
         }
-        const present = new Set(messages.map(message => message.id));
+        const present = new Set(session.deriveMessages().map(message => message.id));
         const text = renderHistory(excludePresentMessages(turns, present), config.timeZone, names(), config.archiveScope === 'home');
-        const oldBlocks = messages.filter(message => message.source.kind === memorySource);
-        for (const [index, message] of oldBlocks.entries()) {
-            if (!included(session)) {
-                retireMemory(session, state);
-                return undefined;
-            }
-            const seq = state.injected.get(message.id);
-            if (seq === undefined || !session.surface.nodes.includes(seq))
-                throw new Error('dsh-world: cannot locate retained injected context in the host surface');
-            const replacement = createUserMessage({ content: [{ type: 'text', text: index === 0 ? text : '' }], source: { kind: memorySource, form: 'recall' } });
-            session.append('user/message', replacement, { surfaceOp: { op: 'replace', startSeq: seq, endSeq: seq }, sourceEventSeqs: [seq] });
-            state.injected.delete(message.id);
-        }
-        if (oldBlocks.length)
-            return undefined;
+        retireMemory(session, state);
         return text ? createUserMessage({ content: [{ type: 'text', text }], source: { kind: memorySource, form: 'recall' } }) : undefined;
     }
     /** Reads what the first catch-up had to leave, once the host can say which sessions belong to her. */
@@ -152,8 +145,6 @@ export function createWorldRuntime(ctx, config, store, world, memoryTurns = () =
                 if (state && event.type === 'step/start')
                     state.position = { turn: event.data.turn, step: event.data.step };
                 const compacted = event.type === 'compaction/end' && event.data.error === undefined;
-                if (state && event.type === 'user/message' && event.data.source.kind === memorySource)
-                    state.injected.set(event.data.id, event.seq);
                 if (state && event.type === 'user/message' && event.data.id === state.pendingId) {
                     state.reload = false;
                     state.pendingId = undefined;
@@ -205,6 +196,13 @@ export function createWorldRuntime(ctx, config, store, world, memoryTurns = () =
                 state.pendingId = block.id;
                 return { ...decision, messages: [block, ...decision.messages] };
             }));
+            // The step is open here and its request is not built yet: the one place retired blocks can be written validly.
+            disposers.push(ctx.on('agent/request', async function (payload, next) {
+                const state = memory.get(payload.agent.session);
+                if (state?.retiring.length)
+                    flushRetired(payload.agent.session, state, { turn: payload.turn, step: payload.step });
+                return next();
+            }));
             disposers.push(ctx.on('llm/stream', async function* (request, next) {
                 const agent = isAgentLoopRequest(request) && request.sessionId ? ctx.agents.get(request.sessionId) : undefined;
                 const owned = agent && included(agent.session);
@@ -212,6 +210,7 @@ export function createWorldRuntime(ctx, config, store, world, memoryTurns = () =
                     const state = memory.get(agent.session);
                     if (state) {
                         retireMemory(agent.session, state);
+                        flushRetired(agent.session, state, state.position);
                         state.restart = true;
                     }
                     yield { type: 'finish', reason: { kind: 'error', failure: { code: 'DSH_WORLD_SCOPE_CHANGED', message: 'dsh-world: 会话已离开世界工作区，已阻止携带世界上下文的请求，请重新发送。' } } };

package/lib/types.d.ts

@@ -10,6 +10,8 @@ export interface WorldConfig {
     archiveScope?: MemoryArchiveScope;
     /** The life line (home session, alarm, tools, console); on by default. */
     life?: boolean;
+    /** On the first start in a profile, switch its stock compaction row to the tool-free one (restart to load it); on by default. */
+    replaceCompaction?: boolean;
     /** Her diary directory; defaults to `<world>/diary`. */
     diaryDir?: string;
     /** Local HH:MM of the morning wake when no alarm is pending (she set none, or cancelled hers); 09:00 by default. */

package/lib/worldSwitch.d.ts

@@ -2,7 +2,7 @@ import { type MemoryArchiveScope } from './archiveSelection.ts';
 /** How many of the newest turns the memory block carries when nothing else is set. */
 export declare const DEFAULT_MEMORY_TURNS = 200;
 /** WeChat group messages read before a mention, and seconds a private image waits for its companions. */
-export declare const DEFAULT_WECHAT_CONTEXT = 8, MAX_WECHAT_CONTEXT = 20;
+export declare const DEFAULT_WECHAT_CONTEXT = 5, MAX_WECHAT_CONTEXT = 20;
 export declare const DEFAULT_WECHAT_BUFFER_SECONDS = 3, MAX_WECHAT_BUFFER_SECONDS = 30;
 /**
  * Her world's own settings, changed from the world console and kept in `<world>/world.json` so they outlast a
@@ -17,6 +17,12 @@ export declare function createWorldSwitch(worldDir: string, configuredScope?: Me
     setArchiveScope(scope: MemoryArchiveScope): void;
     workspacePermission: () => string;
     setWorkspacePermission(permission: string): void;
+    /** After each evening look back her home is applied and compacted, so the 我是谁 she has just rewritten takes effect; on unless the partner turns it off. */
+    compactAfterReview: () => boolean;
+    setCompactAfterReview(on: boolean): void;
+    /** Whether the profile has been switched to the tool-free compaction (by this plugin or by hand); asked once, so putting the stock one back sticks. */
+    compactionSwapped: () => boolean;
+    markCompactionSwapped: () => void;
     running: () => boolean;
     set: (running: boolean) => void;
     /** CNY a day for her home; undefined is no limit. */