@max-null/dsh-memory 0.2.1 → 0.3.7

package/dist/engine.js

@@ -18,7 +18,8 @@ export function MemoryId(id) {
 }
 const blockSchema = z.object({
     namespace: z.enum(['global', 'project']),
-    status: z.enum(['suggested', 'auto', 'suggest']),
+    status: z.enum(['suggested', 'approved', 'auto', 'suggest']),
+    injected: z.boolean().optional(),
     content: z.string(),
     keywords: z.array(z.string()),
     createdAt: z.number(),
@@ -32,8 +33,30 @@ function memorySpec(name) {
         tables: { blocks: domainTable(blockSchema) },
     });
 }
+/**
+ * 旧 schema 迁移（0.3.0，设计文档「迁移规则」）：
+ * - 旧 `auto` → approved + injected:true（行为不变：仍常驻注入）
+ * - 旧 `suggest` → suggested + injected:false
+ * - 缺 injected 的 approved → injected:false（新写路径兜底）
+ * - 其余 → suggested + injected:false
+ */
+function normalizeBlock(block) {
+    if (block.status === 'auto')
+        return { status: 'approved', injected: true };
+    if (block.status === 'suggest')
+        return { status: 'suggested', injected: false };
+    return { status: block.status, injected: block.injected ?? false };
+}
 function toRecord(id, block) {
-    return { id: MemoryId(id), ...block };
+    return {
+        id: MemoryId(id),
+        namespace: block.namespace,
+        ...normalizeBlock(block),
+        content: block.content,
+        keywords: block.keywords,
+        createdAt: block.createdAt,
+        updatedAt: block.updatedAt,
+    };
 }
 /** Harness-home root for `global` memories. */
 function globalRoot() {
@@ -45,56 +68,107 @@ function projectRoot() {
 }
 /**
  * Cross-session plaintext memory over the storage hub, split by namespace:
- * `global` lives in the harness home, `project` in the project folder.
+ * `global` lives in the harness home, `project` in the session's workspace
+ * folder (`<workspace>/.dsh/storages`, follows the repository) — 0.3.4:
+ * project memory routes by the CALLER's workspace cwd (工具/面板按当前会话
+ * 工作区路由), not the process launch dir.
  */
 export class MemoryEngine extends Service {
     config;
     static inject = ['storage'];
     globalTable;
-    projectTable;
+    /** project 域按工作区 cwd 懒打开 + 缓存（多会话并发各工作区独立）。 */
+    projectTables = new Map();
+    projectFacilities = new Map();
+    /** backend 只注册一次（registry 重名抛 duplicate；reload 清缓存后不得重复注册）。 */
+    registeredProjectBackends = new Set();
     facility;
     constructor(ctx, config = {}) {
         super(ctx, 'memory');
         this.config = config;
     }
     async [Service.init]() {
-        await this.openDomains();
-        this.ctx.effect(() => () => { void this.facility?.closeAll(); }, 'memory.domainsClose');
-    }
-    /** 打开两个存储域（init 与 reload 共用）。 */
-    async openDomains() {
+        // backend 只注册一次：registry 对重名注册抛 duplicate-backend
+        // （storage/tests/registry.spec 实测），reload 不得重复注册。
         const globalBackend = new JsonStorageBackend(this.config.globalRoot ?? globalRoot());
-        const projectBackend = new JsonStorageBackend(this.config.projectRoot ?? projectRoot());
         this.ctx.storage.backend.register('memory-global', globalBackend);
-        this.ctx.storage.backend.register('memory-project', projectBackend);
-        const facility = new DomainFacility(this.ctx, {
-            backend: 'memory-global',
-            routes: { memory_project: 'memory-project' },
-        });
+        await this.openGlobalFacility();
+        this.ctx.effect(() => () => {
+            void this.facility?.closeAll();
+            for (const facility of this.projectFacilities.values())
+                void facility.closeAll();
+        }, 'memory.domainsClose');
+    }
+    /** 打开全局存储域（init 与 reload 共用；backend 复用已注册实例）。 */
+    async openGlobalFacility() {
+        const facility = new DomainFacility(this.ctx, { backend: 'memory-global', routes: {} });
         const globalDomain = await facility.open(memorySpec('memory'));
-        const projectDomain = await facility.open(memorySpec('memory_project'));
         this.facility = facility;
         this.globalTable = globalDomain.table('blocks');
-        this.projectTable = projectDomain.table('blocks');
+    }
+    /** 工作区 project 存储根（<workspace>/.dsh/storages，随 git 分享）。 */
+    projectRootFor(cwd) {
+        return join(cwd, '.dsh', 'storages');
+    }
+    /** 稳定 backend 名（registry 重名抛错，按 cwd hash 唯一化；只允许 [a-z0-9_]，domain 名校验）。 */
+    projectBackendName(cwd) {
+        let h = 5381;
+        const text = cwd.toLowerCase(); // Windows 路径大小写不敏感
+        for (let i = 0; i < text.length; i++)
+            h = ((h << 5) + h + text.charCodeAt(i)) | 0;
+        return `memory_project_${Math.abs(h).toString(36)}`;
     }
     /**
-     * 强制重载存储：关闭两域后重开，放弃内存缓存重读文件。
-     * 供外部编辑记忆文件后刷新（JsonStorageBackend 打开时加载一次，
-     * 无 watch——2026-08-19 用户实测面板不感知外部编辑）。
+     * 按工作区 cwd 取 project 表（懒打开 + 缓存）。无 cwd（未选工作区）
+     * 返回 undefined——调用方（工具/面板）按此跳过 project 部分。
+     */
+    async projectTableFor(projectCwd) {
+        if (projectCwd === undefined || projectCwd === '')
+            return undefined;
+        const key = join(projectCwd); // 规范化（Windows 大小写/尾斜杠）
+        const cached = this.projectTables.get(key);
+        if (cached !== undefined)
+            return cached;
+        const backendName = this.projectBackendName(key);
+        if (!this.registeredProjectBackends.has(backendName)) {
+            const backend = new JsonStorageBackend(this.projectRootFor(key));
+            this.ctx.storage.backend.register(backendName, backend);
+            this.registeredProjectBackends.add(backendName);
+        }
+        const facility = new DomainFacility(this.ctx, { backend: backendName, routes: {} });
+        const domain = await facility.open(memorySpec(`memory_project_${backendName}`));
+        const table = domain.table('blocks');
+        this.projectFacilities.set(key, facility);
+        this.projectTables.set(key, table);
+        return table;
+    }
+    /**
+     * 强制重载存储：关闭全局域与全部已开工作区域后重开（unit 释放后
+     * backend 重读文件），放弃内存缓存。供外部编辑记忆文件后刷新
+     * （JsonStorageBackend 打开时加载一次，无 watch——2026-08-19 实测）。
      */
     async reload() {
         await this.facility?.closeAll();
-        await this.openDomains();
+        for (const facility of this.projectFacilities.values())
+            await facility.closeAll();
+        this.projectTables.clear();
+        this.projectFacilities.clear();
+        await this.openGlobalFacility();
     }
     /** Create one record in `suggested` status — never self-promoting. */
-    async remember(input) {
+    async remember(input, projectCwd) {
         const namespace = input.namespace ?? 'global';
-        const table = this.tableFor(namespace);
+        const table = namespace === 'project'
+            ? await this.projectTableFor(projectCwd)
+            : this.tableFor('global');
+        if (table === undefined)
+            throw new Error('cannot write project memory without a workspace cwd');
         const id = randomUUID();
         const now = Date.now();
         const block = {
             namespace,
             status: 'suggested',
+            injected: false,
             content: input.content,
             keywords: (input.keywords ?? []).map(keyword => keyword.toLowerCase()),
             createdAt: now,
@@ -105,12 +179,13 @@ export class MemoryEngine extends Service {
         this.ctx.emit('memory/changed', { operation: 'remembered', record });
         return record;
     }
-    list(filter) {
-        const records = this.allRecords(filter?.namespace);
-        return records.filter(record => (filter?.status === undefined || record.status === filter.status));
+    async list(filter, projectCwd) {
+        const records = await this.allRecords(filter?.namespace, projectCwd);
+        return records.filter(record => (filter?.status === undefined || record.status === filter.status)
+            && (filter?.injected === undefined || record.injected === filter.injected));
     }
-    search(query, filter) {
-        const records = this.list(filter);
+    async search(query, filter, projectCwd) {
+        const records = await this.list(filter, projectCwd);
         const docs = records.map(record => `${record.content} ${record.keywords.join(' ')}`);
         const scores = bm25Scores(query, docs);
         return records
@@ -118,44 +193,146 @@ export class MemoryEngine extends Service {
             .filter(hit => hit.score > 0)
             .sort((left, right) => right.score - left.score);
     }
-    async forget(id) {
+    async forget(id, projectCwd) {
         if (await this.requireTable('global').delete(id)) {
             this.ctx.emit('memory/changed', { operation: 'forgotten', id });
             return true;
         }
-        if (await this.requireTable('project').delete(id)) {
+        const project = await this.projectTableFor(projectCwd);
+        if (project !== undefined && await project.delete(id)) {
             this.ctx.emit('memory/changed', { operation: 'forgotten', id });
             return true;
         }
         return false;
     }
-    async setStatus(id, status) {
+    async setStatus(id, status, projectCwd) {
         const global = this.requireTable('global').get(id);
         if (global !== undefined) {
-            const updated = { ...global, status, updatedAt: Date.now() };
+            const updated = {
+                ...global,
+                status,
+                // 旧数据可能缺 injected，写回时补全（读时迁移值）
+                injected: normalizeBlock(global).injected,
+                updatedAt: Date.now(),
+            };
             await this.requireTable('global').put(id, updated);
             const record = toRecord(id, updated);
             this.ctx.emit('memory/changed', { operation: 'status', id, status });
             return record;
         }
-        const project = this.requireTable('project').get(id);
+        const project = await this.projectTableFor(projectCwd);
         if (project !== undefined) {
-            const updated = { ...project, status, updatedAt: Date.now() };
-            await this.requireTable('project').put(id, updated);
+            const block = project.get(id);
+            if (block !== undefined) {
+                const updated = {
+                    ...block,
+                    status,
+                    injected: normalizeBlock(block).injected,
+                    updatedAt: Date.now(),
+                };
+                await project.put(id, updated);
+                const record = toRecord(id, updated);
+                this.ctx.emit('memory/changed', { operation: 'status', id, status });
+                return record;
+            }
+        }
+        throw new Error(`cannot set status of unknown memory '${id}'`);
+    }
+    /**
+     * 注入维度开关（0.3.0）：只改 injected，不动审核状态。供 UI 面板
+     * 「常驻注入」开关调用（remote.setInjected）。
+     */
+    async setInjected(id, injected, projectCwd) {
+        const global = this.requireTable('global').get(id);
+        if (global !== undefined) {
+            const updated = {
+                ...global,
+                status: normalizeBlock(global).status,
+                injected,
+                updatedAt: Date.now(),
+            };
+            await this.requireTable('global').put(id, updated);
             const record = toRecord(id, updated);
-            this.ctx.emit('memory/changed', { operation: 'status', id, status });
+            this.ctx.emit('memory/changed', { operation: 'injected', id, injected });
             return record;
         }
-        throw new Error(`cannot set status of unknown memory '${id}'`);
+        const project = await this.projectTableFor(projectCwd);
+        if (project !== undefined) {
+            const block = project.get(id);
+            if (block !== undefined) {
+                const updated = {
+                    ...block,
+                    status: normalizeBlock(block).status,
+                    injected,
+                    updatedAt: Date.now(),
+                };
+                await project.put(id, updated);
+                const record = toRecord(id, updated);
+                this.ctx.emit('memory/changed', { operation: 'injected', id, injected });
+                return record;
+            }
+        }
+        throw new Error(`cannot set injected of unknown memory '${id}'`);
+    }
+    /**
+     * 修改一条记忆的内容/关键词（0.3.1 整理记忆用）。内容被模型改动后
+     * 必须重新人工审核：status 重置为 suggested（自然停止注入——注入仅对
+     * approved 生效）；injected 保留原值（审核通过后注入开关原样恢复）。
+     */
+    async update(id, patch, projectCwd) {
+        const applyPatch = (block) => {
+            const normalized = normalizeBlock(block);
+            return {
+                ...block,
+                status: 'suggested',
+                injected: normalized.injected,
+                ...(patch.content === undefined ? {} : { content: patch.content }),
+                ...(patch.keywords === undefined ? {} : { keywords: patch.keywords.map(keyword => keyword.toLowerCase()) }),
+                updatedAt: Date.now(),
+            };
+        };
+        const global = this.requireTable('global').get(id);
+        if (global !== undefined) {
+            const updated = applyPatch(global);
+            await this.requireTable('global').put(id, updated);
+            const record = toRecord(id, updated);
+            this.ctx.emit('memory/changed', { operation: 'status', id, status: 'suggested' });
+            return record;
+        }
+        const project = await this.projectTableFor(projectCwd);
+        if (project !== undefined) {
+            const block = project.get(id);
+            if (block !== undefined) {
+                const updated = applyPatch(block);
+                await project.put(id, updated);
+                const record = toRecord(id, updated);
+                this.ctx.emit('memory/changed', { operation: 'status', id, status: 'suggested' });
+                return record;
+            }
+        }
+        throw new Error(`cannot update unknown memory '${id}'`);
     }
-    allRecords(namespace) {
-        if (namespace === 'project')
-            return this.recordsOf(this.requireTable('project'));
+    /**
+     * 注入专用（0.3.4）：systemPrompt context 是同步回调、无会话 cwd 可及，
+     * 只返回 global 的 approved+injected（工作区记忆走检索/面板）。
+     */
+    recallRecords() {
+        return this.recordsOf(this.requireTable('global'))
+            .filter(record => record.status === 'approved' && record.injected);
+    }
+    async allRecords(namespace, projectCwd) {
+        if (namespace === 'project') {
+            const project = await this.projectTableFor(projectCwd);
+            if (project === undefined)
+                return [];
+            return this.recordsOf(project);
+        }
         if (namespace === 'global')
             return this.recordsOf(this.requireTable('global'));
+        const project = await this.projectTableFor(projectCwd);
         return [
             ...this.recordsOf(this.requireTable('global')),
-            ...this.recordsOf(this.requireTable('project')),
+            ...(project === undefined ? [] : this.recordsOf(project)),
         ];
     }
     recordsOf(table) {
@@ -165,7 +342,7 @@ export class MemoryEngine extends Service {
         return this.requireTable(namespace);
     }
     requireTable(namespace) {
-        const table = namespace === 'global' ? this.globalTable : this.projectTable;
+        const table = namespace === 'global' ? this.globalTable : undefined;
         if (table === undefined)
             throw new Error('memory engine is not started yet');
         return table;

package/dist/index.js

@@ -7,18 +7,21 @@
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { MemoryEngine } from "./engine.js";
 import { MemoryGateway } from "./remote.js";
+import { mountMemoryApi } from "./routes.js";
+import { SELF_DESCRIPTION } from "./self.js";
 export { MemoryEngine } from "./engine.js";
 export { MemoryId } from "./engine.js";
 export { bm25Scores, tokenize } from "./bm25.js";
 export const name = 'dsh-memory';
-export const inject = ['storage', 'systemPrompt', 'tools'];
+export const inject = ['storage', 'systemPrompt', 'tools', 'webServer', 'webRuntime'];
 const RECORD_SCHEMA = {
     type: 'object',
     additionalProperties: false,
     properties: {
         id: { type: 'string', required: true },
         namespace: { type: 'string', required: true, enum: ['global', 'project'] },
-        status: { type: 'string', required: true, enum: ['suggested', 'auto', 'suggest'] },
+        status: { type: 'string', required: true, enum: ['suggested', 'approved'] },
+        injected: { type: 'boolean', required: true },
         content: { type: 'string', required: true },
         keywords: { type: 'array', required: true, items: { type: 'string' } },
         createdAt: { type: 'number', required: true },
@@ -38,6 +41,7 @@ function recordValue(record) {
         id: String(record.id),
         namespace: record.namespace,
         status: record.status,
+        injected: record.injected,
         content: record.content,
         keywords: record.keywords,
         createdAt: record.createdAt,
@@ -47,17 +51,34 @@ function recordValue(record) {
 function hitValue(hit) {
     return { record: recordValue(hit.record), score: hit.score };
 }
+// 0.3.0：审核语义双语（host 侧 GUIDANCE 无法跟随 DSH locale 动态切换，
+// 采用中英双语都写、模型自取——设计文档「风险与注意」）。
 const GUIDANCE = 'Use memory tools for cross-session preferences, habits, and project conventions. '
+    + '记忆工具用于跨会话的偏好、习惯与项目约定。'
     + 'memory_save always records a suggestion (`suggested`) and never makes it effective itself — '
-    + 'a human confirms it. When earlier context may be relevant, call memory_search to recall it. '
-    + 'Every memory is plaintext and inspectable with memory_list; memory_forget removes one.';
+    + 'a human approves it. memory_save 永远只写入建议（`suggested`），不会自行生效——需人工审核通过。'
+    + 'Approval only marks the content reviewed; whether it is injected every turn is a separate '
+    + 'human-controlled switch (`injected`). 审核通过只代表内容被认可；是否每轮常驻注入由独立的'
+    + '人工开关（`injected`）控制。'
+    + 'When earlier context may be relevant, call memory_search to recall it — reviewable memories '
+    + '(`suggested`) are searchable too. 相关历史上下文可用 memory_search 检索——待审核的记忆也可检索。'
+    + 'Every memory is plaintext and inspectable with memory_list; memory_forget removes one. '
+    + '所有记忆均为明文，可用 memory_list 查看；memory_forget 删除一条。';
+// 0.3.4：注入只注入 global 的 approved+injected（systemPrompt context 是
+// 同步回调、无会话 cwd 可及）；工作区（project）记忆按会话 cwd 路由，靠
+// memory_search / 面板访问。
 function recallText(memory) {
-    const auto = memory.list({ status: 'auto' });
+    const auto = memory.recallRecords();
     if (auto.length === 0)
         return '';
     const lines = auto.map(record => `- [memory:${String(record.id)}] ${record.content}`);
     return `Remembered preferences and conventions — apply these:\n${lines.join('\n')}`;
 }
+/** 从工具执行上下文取调用会话的工作区 cwd（0.3.4 工作区路由）。 */
+function execProjectCwd(exec) {
+    return exec
+        ?.agent?.session?.header?.cwd;
+}
 function renderJson(value) {
     return [{ type: 'text', text: JSON.stringify(value) }];
 }
@@ -67,6 +88,8 @@ function present(title, kind, rawInput) {
 export async function apply(ctx, config) {
     await ctx.plugin(MemoryEngine, config);
     await ctx.plugin(MemoryGateway);
+    // 0.3.6：自带面板数据通道（HTTP，独立包无需 Typert 构建产物）
+    mountMemoryApi(ctx);
     const memory = ctx.get('memory');
     if (memory === undefined)
         throw new Error('memory engine failed to register');
@@ -75,6 +98,13 @@ export async function apply(ctx, config) {
         order: 115,
         text: GUIDANCE,
     });
+    // 0.3.2：记忆机制自述——常驻注入（不落用户存储），随发版更新。
+    // order 49 < recall(50)：机制说明在具体记忆内容之前。
+    ctx.systemPrompt.context({
+        name: 'memory:self',
+        order: 49,
+        text: SELF_DESCRIPTION,
+    });
     ctx.systemPrompt.context({
         name: 'memory:recall',
         order: 50,
@@ -92,51 +122,53 @@ export async function apply(ctx, config) {
             schema: RECORD_SCHEMA,
             render: (_args, value) => renderJson(value),
         },
-        execute(args, _exec) {
+        execute(args, exec) {
             return memory.remember({
                 content: args.content,
                 ...args.namespace === undefined ? {} : { namespace: args.namespace },
                 ...args.keywords === undefined ? {} : { keywords: args.keywords },
-            }).then(recordValue);
+            }, execProjectCwd(exec)).then(recordValue);
         },
         presentCall: args => present('Save memory', 'other', args.content),
     }));
     ctx.tools.register(defineTool({
         name: 'memory_list',
-        description: 'List every stored memory, optionally filtered by namespace or status. Every memory is plaintext and inspectable.',
+        description: 'List every stored memory, optionally filtered by namespace, status, or injected switch. Every memory is plaintext and inspectable. 列出全部记忆，可按 namespace/status/injected 过滤；均为明文可查。',
         parameters: {
-            namespace: { type: 'string', enum: ['global', 'project'], description: 'Restrict to one namespace.' },
-            status: { type: 'string', enum: ['suggested', 'auto', 'suggest'], description: 'Restrict to one status.' },
+            namespace: { type: 'string', enum: ['global', 'project'], description: 'Restrict to one namespace. 限定单个命名空间.' },
+            status: { type: 'string', enum: ['suggested', 'approved'], description: 'Restrict to one review status. 限定审核状态（suggested=待审核 / approved=已审核）.' },
+            injected: { type: 'boolean', description: 'Restrict by the persistent-injection switch. 按常驻注入开关过滤.' },
         },
         output: {
             schema: { type: 'array', items: RECORD_SCHEMA },
             render: (_args, value) => renderJson(value),
         },
-        execute(args, _exec) {
-            return Promise.resolve(memory.list({
+        execute(args, exec) {
+            return memory.list({
                 ...args.namespace === undefined ? {} : { namespace: args.namespace },
                 ...args.status === undefined ? {} : { status: args.status },
-            }).map(recordValue));
+                ...args.injected === undefined ? {} : { injected: args.injected },
+            }, execProjectCwd(exec)).then(records => records.map(recordValue));
         },
         presentCall: () => present('List memories', 'read'),
     }));
     ctx.tools.register(defineTool({
         name: 'memory_search',
-        description: 'Recall stored memories by keyword. Deterministic literal matching — a miss means no stored term matched the query.',
+        description: 'Recall stored memories by keyword. Deterministic literal matching — a miss means no stored term matched the query. 按关键词检索记忆（含待审核条目）。',
         parameters: {
-            query: { type: 'string', required: true, description: 'Keyword query.' },
-            namespace: { type: 'string', enum: ['global', 'project'], description: 'Restrict to one namespace.' },
-            status: { type: 'string', enum: ['suggested', 'auto', 'suggest'], description: 'Restrict to one status.' },
+            query: { type: 'string', required: true, description: 'Keyword query. 关键词查询.' },
+            namespace: { type: 'string', enum: ['global', 'project'], description: 'Restrict to one namespace. 限定单个命名空间.' },
+            status: { type: 'string', enum: ['suggested', 'approved'], description: 'Restrict to one review status. 限定审核状态.' },
         },
         output: {
             schema: { type: 'array', items: HIT_SCHEMA },
             render: (_args, value) => renderJson(value),
         },
-        execute(args, _exec) {
-            return Promise.resolve(memory.search(args.query, {
+        execute(args, exec) {
+            return memory.search(args.query, {
                 ...args.namespace === undefined ? {} : { namespace: args.namespace },
                 ...args.status === undefined ? {} : { status: args.status },
-            }).map(hitValue));
+            }, execProjectCwd(exec)).then(hits => hits.map(hitValue));
         },
         presentCall: args => present('Search memory', 'read', args.query),
     }));
@@ -150,23 +182,43 @@ export async function apply(ctx, config) {
             schema: { type: 'object', additionalProperties: false, properties: { deleted: { type: 'boolean', required: true } } },
             render: (_args, value) => renderJson(value),
         },
-        execute(args, _exec) {
-            return memory.forget(args.id).then(deleted => ({ deleted }));
+        execute(args, exec) {
+            return memory.forget(args.id, execProjectCwd(exec)).then(deleted => ({ deleted }));
         },
         presentCall: args => present('Forget memory', 'other', args.id),
     }));
+    ctx.tools.register(defineTool({
+        name: 'memory_update',
+        description: 'Update the content or keywords of one stored memory (e.g. correcting stale facts). The record is re-marked `suggested` — the human must review it again before it is approved/injected again. 修改一条记忆的内容或关键词（如修正过时信息）。改动后该记忆重置为待审核（suggested），需人工再次审核；常驻注入开关保留原值（审核通过后恢复）。',
+        parameters: {
+            id: { type: 'string', required: true, description: 'Exact memory id from memory_list. 记忆 id（来自 memory_list）.' },
+            content: { type: 'string', description: 'New content; omit to keep current. 新内容；省略则保留现有内容.' },
+            keywords: { type: 'array', items: { type: 'string' }, description: 'New keywords; omit to keep current. 新关键词；省略则保留现有.' },
+        },
+        output: {
+            schema: RECORD_SCHEMA,
+            render: (_args, value) => renderJson(value),
+        },
+        execute(args, exec) {
+            return memory.update(args.id, {
+                ...args.content === undefined ? {} : { content: args.content },
+                ...args.keywords === undefined ? {} : { keywords: args.keywords },
+            }, execProjectCwd(exec)).then(recordValue);
+        },
+        presentCall: args => present('Update memory', 'other', args.id),
+    }));
     ctx.tools.register(defineTool({
         name: 'memory_confirm',
-        description: 'Confirm a suggested memory so it becomes effective (`auto`). Only call this when the human explicitly asks to confirm a memory; never self-promote a suggestion.',
+        description: 'Approve a suggested memory so it is marked human-reviewed (`approved`). Approval does NOT enable persistent injection — whether a memory is injected every turn is a separate human-controlled switch (`injected`). Only call this when the human explicitly asks to approve a memory; never self-promote a suggestion. 将待审核记忆标记为已审核（approved）。审核通过不改变注入状态——是否每轮常驻注入由独立的人工开关（injected）控制。仅在用户明确要求审核某条记忆时调用；模型不得自我提升。',
         parameters: {
-            id: { type: 'string', required: true, description: 'Exact memory id from memory_list.' },
+            id: { type: 'string', required: true, description: 'Exact memory id from memory_list. 记忆 id（来自 memory_list）.' },
         },
         output: {
             schema: RECORD_SCHEMA,
             render: (_args, value) => renderJson(value),
         },
-        execute(args, _exec) {
-            return memory.setStatus(args.id, 'auto').then(recordValue);
+        execute(args, exec) {
+            return memory.setStatus(args.id, 'approved', execProjectCwd(exec)).then(recordValue);
         },
         presentCall: args => present('Confirm memory', 'other', args.id),
     }));

package/dist/remote.d.ts

@@ -13,13 +13,28 @@ import type { MemoryFilter, MemoryHit, MemoryRecord } from './engine.ts';
 export declare class MemoryGateway extends TypertRemoteService {
     static inject: string[];
     constructor(ctx: Context);
-    /** List every stored memory, optionally filtered by namespace or status. */
-    list(filter?: MemoryFilter): MemoryRecord[];
+    /** List every stored memory, optionally filtered by namespace/status/injected and workspace cwd. */
+    list(filter?: MemoryFilter, cwd?: string): Promise<MemoryRecord[]>;
     /** Recall memories by keyword; deterministic literal matching. */
-    search(query: string, filter?: MemoryFilter): MemoryHit[];
-    /** Confirm a suggested memory so it becomes effective (`auto`). */
-    confirm(id: string): Promise<MemoryRecord>;
+    search(query: string, filter?: MemoryFilter, cwd?: string): Promise<MemoryHit[]>;
+    /** Approve a suggested memory (review status `suggested` → `approved`); does not change injection. */
+    confirm(id: string, cwd?: string): Promise<MemoryRecord>;
+    /**
+     * Toggle the persistent-injection switch (`injected`) — the UI panel's
+     * 「常驻注入」 switch; does not change the review status.
+     */
+    setInjected(id: string, injected: boolean, cwd?: string): Promise<MemoryRecord>;
     /** Delete one stored memory by id. */
-    forget(id: string): Promise<boolean>;
+    forget(id: string, cwd?: string): Promise<boolean>;
+    /** Force-reload storage files (external edits; JsonStorageBackend has no watch). */
+    reload(cwd?: string): Promise<MemoryRecord[]>;
+    /**
+     * 注入预览（0.3.5）：开发者查看当前注入到 system prompt 的记忆内容
+     * ——self 自述 + 实际注入的 global approved+injected 记忆。
+     */
+    injectionPreview(): {
+        self: string;
+        injected: MemoryRecord[];
+    };
 }
 export default MemoryGateway;