dsh-lite-memory 0.11.1 → 0.16.2

package/test/contract.test.mjs

@@ -108,13 +108,13 @@ assert.equal(phrased.scope, 'project');
 assert.equal(store.loadIndex(store.globalScope()).entries.some((item) => item.title === '以后都用这个一次性脚本'), false);
 
 assert.equal(typeof saved.id, 'string');
-assert.match(render('memory_save', {}, saved), /^memory · saved "发布顺序" · mem_[a-z0-9]+ · 第 1 版$/);
+assert.match(render('memory_save', {}, saved), /^memory · saved \[[^\]]+\] "发布顺序" · mem_[a-z0-9]+$/);
 
 const merged = await exec('memory_save', { title: '发布顺序', summary: '发版前要按顺序做的事', body: '第一步\n第二步' });
 assert.equal(merged.merged, true);
 assert.equal(merged.id, saved.id);
 assert.equal(merged.revision, 2);
-assert.match(render('memory_save', {}, merged), /^memory · merged "发布顺序" · mem_[a-z0-9]+ · 第 2 版$/);
+assert.match(render('memory_save', {}, merged), /^memory · merged \[[^\]]+\] "发布顺序" · mem_[a-z0-9]+$/);
 
 const patch = await exec('memory_save', { id: saved.id, title: '发布顺序', summary: '发版前要按顺序做的事', when: '发版当天' });
 assert.equal(patch.when, '发版当天');
@@ -125,7 +125,7 @@ const again = await exec('memory_save', { title: '发布顺序', summary: '发
 assert.equal(again.changed, false);
 assert.equal(again.id, saved.id);
 assert.equal(again.revision, 3);
-assert.match(render('memory_save', {}, again), /^memory · unchanged "发布顺序" · mem_[a-z0-9]+ · 第 3 版$/);
+assert.match(render('memory_save', {}, again), /^memory · unchanged \[[^\]]+\] "发布顺序" · mem_[a-z0-9]+$/);
 
 // ── similar title asks before overwriting ────────────────────────────────────
 const probe = await exec('memory_save', { title: '发布顺序是啥', summary: '发版前要按顺序做的事', body: '另一条' });
@@ -147,16 +147,20 @@ const hits = await exec('memory_search', { query: '发布流程' });
 assert.ok(hits.count >= 1);
 assert.ok(hits.chars > 0);
 const hitText = render('memory_search', {}, hits);
-assert.match(hitText, new RegExp(`^memory · 命中 ${hits.count} 条 · 引用 ${hits.chars} 字\\n- mem_`));
-assert.match(hitText, /第 3 版/);
+assert.match(hitText, new RegExp(`^memory · 命中 ${hits.count} 条 · 引用 ${hits.chars} 字\\n- \\[[^\\]]+\\] mem_`));
+assert.doesNotMatch(hitText, /第 .* 版/);
+/** 「发版当天」这类自由文本条件没有可信上下文，不能当成适用条目塞给模型。 */
 const miss = await exec('memory_search', { query: '完全没有出现过的主题' });
 assert.equal(miss.count, 0);
 assert.equal(render('memory_search', {}, miss), 'memory · 没有命中');
 
 const read = await exec('memory_read', { id: saved.id });
-assert.equal(read.body, '第一步\n第二步');
-assert.equal(read.revision, 3);
-assert.match(render('memory_read', {}, read), new RegExp(`^memory · 「发布顺序」（发版当天） · ${saved.id} · 第 3 版`));
+assert.equal(read.status, 'needs_context');
+assert.equal(read.body, '');
+const plain = await exec('memory_read', { id: distinct.id });
+assert.equal(plain.body, '另一条');
+assert.equal(plain.revision, 1);
+assert.match(render('memory_read', {}, plain), new RegExp(`^memory · \\[[^\\]]+\\] 「发布顺序是啥」 · ${distinct.id}`));
 
 // 没点明归档还是彻底忘掉时不动盘，先返回待确认
 const undecided = await exec('memory_forget', { id: distinct.id });
@@ -165,7 +169,7 @@ assert.match(render('memory_forget', {}, undecided), new RegExp(`^memory · 先
 assert.ok(store.locate(store.scopeOf(cwd), distinct.id));
 const archived = await exec('memory_forget', { id: distinct.id, mode: 'archive' });
 assert.equal(archived.id, distinct.id);
-assert.match(render('memory_forget', {}, archived), new RegExp(`^memory · archived "发布顺序是啥" · ${distinct.id}，可找回$`));
+assert.match(render('memory_forget', {}, archived), new RegExp(`^memory · archived \\[[^\\]]+\\] "发布顺序是啥" · ${distinct.id}，可找回$`));
 assert.equal(await exec('memory_save', { title: '发布顺序是啥', summary: '发版前要按顺序做的事', body: '第三条' }).then((v) => v.merged), false);
 
 // ── suggestion → keep → replay → reject ──────────────────────────────────────
@@ -227,10 +231,10 @@ assert.equal((await call('/lite-memory/keep', {}, { method: 'GET' })).status, 40
 // ── global layer ─────────────────────────────────────────────────────────────
 const global = await exec('memory_save', { title: '回复用中文', summary: '用户要求回复用中文', scope: 'global' });
 assert.equal(global.scope, 'global');
-assert.match(render('memory_save', {}, global), /^memory · saved \[全局\] "回复用中文" · mem_[a-z0-9]+ · 第 1 版$/);
+assert.match(render('memory_save', {}, global), /^memory · saved \[global\] "回复用中文" · mem_[a-z0-9]+$/);
 const globalSearch = await exec('memory_search', { query: '回复用中文' });
 assert.equal(globalSearch.count, 1);
-assert.match(render('memory_search', {}, globalSearch), /\[全局\] mem_/);
+assert.match(render('memory_search', {}, globalSearch), /\[global\] mem_/);
 assert.equal(typeof globalThis.__liteMemoryStats, 'function');
 const stats = globalThis.__liteMemoryStats(cwd);
 assert.ok(stats.count >= 1);
@@ -415,6 +419,102 @@ const evoDelete = await call('/lite-memory/evolution', {
 assert.equal(evoDelete.status, 200);
 assert.equal(evoDelete.body.ok, true);
 
+// 管理面成功路径：候选可修改、采纳、暂停、恢复、放弃，每次返回后能继续操作
+const manageSeed = await defs.get('memory_save').execute(
+  { title: '口播收尾', summary: '口播收尾留一句行动', body: '结尾给一句具体行动。' },
+  { agent: evoAgent },
+);
+state.transact(evoReadScope, {}, (draft) => {
+  const row = draft.entries.find((entry) => entry.id === manageSeed.id);
+  row.origin = 'project_evolution';
+  row.current.conditions = [{ key: 'seriesId', value: '口播' }];
+  row.maintenance = { ...(row.maintenance || {}), learning: { state: 'pending', source: 'evolution' } };
+  return { changed: true };
+});
+const manageSnap = await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' });
+const manageRule = manageSnap.body.rules.find((rule) => rule.id === manageSeed.id);
+assert.ok(manageRule);
+assert.equal(manageRule.state, 'pending');
+const manageEdit = await call('/lite-memory/evolution', {
+  sessionId: 'session-evo-read', learningAction: 'edit', id: manageSeed.id,
+  expectedRevision: manageRule.revision, body: '结尾给一句具体动作。',
+});
+assert.equal(manageEdit.status, 200);
+assert.equal(manageEdit.body.ok, true);
+const afterManageEdit = (await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' })).body.rules.find((rule) => rule.id === manageSeed.id);
+assert.equal(afterManageEdit.state, 'pending');
+assert.equal(afterManageEdit.body, '结尾给一句具体动作。');
+const manageAdopt = await call('/lite-memory/evolution', {
+  sessionId: 'session-evo-read', learningAction: 'adopt', id: manageSeed.id, expectedRevision: afterManageEdit.revision,
+});
+assert.equal(manageAdopt.status, 200);
+assert.equal((await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' })).body.rules.find((rule) => rule.id === manageSeed.id).state, 'active');
+const managePause = await call('/lite-memory/evolution', {
+  sessionId: 'session-evo-read', learningAction: 'pause', ids: [manageSeed.id],
+});
+assert.equal(managePause.status, 200);
+assert.equal((await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' })).body.rules.find((rule) => rule.id === manageSeed.id).state, 'paused');
+const manageResume = await call('/lite-memory/evolution', {
+  sessionId: 'session-evo-read', learningAction: 'resume', id: manageSeed.id,
+});
+assert.equal(manageResume.status, 200);
+const manageResumed = (await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' })).body.rules.find((rule) => rule.id === manageSeed.id);
+assert.equal(manageResumed.state, 'trial');
+const manageDiscard = await call('/lite-memory/evolution', {
+  sessionId: 'session-evo-read', learningAction: 'discard', id: manageSeed.id, expectedRevision: manageResumed.revision,
+});
+assert.equal(manageDiscard.status, 200);
+assert.equal((await call('/lite-memory/evolution', { sessionId: 'session-evo-read', learningAction: 'snapshot' })).body.rules.length, 0);
+
+// ── 关闭项目记忆后：面板只读，管理面写操作全部拒绝，工具也不落盘 ─────────────
+const closedCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-closed-'));
+sessionCwds.set('session-closed', closedCwd);
+const closedScope = store.scopeOf(closedCwd);
+const closedAgent = { id: 'session-closed', cwd: closedCwd, session: { id: 'session-closed', header: { cwd: closedCwd } } };
+const closedSeed = await defs.get('memory_save').execute(
+  { title: '口播开头', summary: '口播开头三句内给结论', body: '开场三句内给结论。' },
+  { agent: closedAgent },
+);
+state.transact(closedScope, {}, (draft) => {
+  const row = draft.entries.find((entry) => entry.id === closedSeed.id);
+  row.origin = 'project_evolution';
+  row.maintenance = { ...(row.maintenance || {}), learning: { state: 'active' } };
+  return { changed: true };
+});
+assert.equal((await call('/lite-memory/evolution', { sessionId: 'session-closed', enabled: true })).status, 200);
+const closedOff = await call('/lite-memory/control', { sessionId: 'session-closed', enabled: false, operationId: 'op_close_contract' });
+assert.equal(closedOff.status, 200);
+assert.equal(closedOff.body.enabled, false);
+const closedFile = path.join(closedScope.dir, 'state.json');
+const closedBefore = fs.readFileSync(closedFile);
+const closedSnapshot = await call('/lite-memory/evolution', { sessionId: 'session-closed', learningAction: 'snapshot' });
+assert.equal(closedSnapshot.status, 200);
+assert.equal(closedSnapshot.body.enabled, false);
+assert.equal(closedSnapshot.body.rules.length, 1);
+assert.equal(Buffer.compare(closedBefore, fs.readFileSync(closedFile)), 0);
+const closedRevision = closedSnapshot.body.rules[0].revision;
+for (const action of ['adopt', 'edit', 'delete', 'pause', 'resume', 'pin', 'undo']) {
+  const payload = { sessionId: 'session-closed', learningAction: action, id: closedSeed.id, expectedRevision: closedRevision, body: '改过的正文' };
+  if (action === 'pin') payload.pinned = true;
+  if (action === 'pause') payload.ids = [closedSeed.id];
+  const result = await call('/lite-memory/evolution', payload);
+  assert.equal(result.status, 409, action);
+  assert.equal(result.body.code, 'memory_disabled', action);
+}
+const closedTool = await defs.get('memory_save').execute(
+  { title: '关闭后写入', summary: '应当拒绝', body: '不该落盘' },
+  { agent: closedAgent },
+);
+assert.equal(closedTool.changed, false);
+assert.equal(closedTool.reason, 'memory_disabled');
+assert.equal(closedTool.id, '');
+assert.equal(Buffer.compare(closedBefore, fs.readFileSync(closedFile)), 0);
+const reopened = await call('/lite-memory/control', { sessionId: 'session-closed', enabled: true, operationId: 'op_reopen_contract' });
+assert.equal(reopened.status, 200);
+const reopenedSnapshot = await call('/lite-memory/evolution', { sessionId: 'session-closed', learningAction: 'snapshot' });
+assert.equal(reopenedSnapshot.body.enabled, false);
+assert.equal(reopenedSnapshot.body.rules.length, 1);
+
 // ── 界面只吃持久元数据，不猜文案 ─────────────────────────────────────────────
 const metaOf = (name, args, value) => defs.get(name).output.presentationMeta(args, value);
 const savedMeta = metaOf('memory_save', {}, saved);
@@ -674,4 +774,107 @@ assert.equal(orgEconomy2.knownCalls, 3);
 assert.equal(orgEconomy2.inputTokens, 36);
 llmImpl = null;
 
+// ── 记忆面板总览：只读枚举各项目层，正文按 scopeKey 单读，不泄露内部路径 ──────
+const ovCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-overview-'));
+const ovOtherCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-overview-other-'));
+sessionCwds.set('session-overview', ovCwd);
+sessionCwds.set('session-overview-other', ovOtherCwd);
+const ovAgent = { id: 'session-overview', cwd: ovCwd, session: { id: 'session-overview', header: { cwd: ovCwd } } };
+const ovFirst = await defs.get('memory_save').execute(
+  { title: '开场先给结论', summary: '口播开头先给结论', body: '开场三句内给结论。', tags: ['口播', '开头'], links: [] },
+  { agent: ovAgent },
+);
+const ovSecond = await defs.get('memory_save').execute(
+  { title: '封面留白', summary: '封面别放满', body: '右侧留白。', tags: ['封面'] },
+  { agent: ovAgent },
+);
+await defs.get('memory_save').execute(
+  { title: '观察全局', summary: '跨项目通用说明', body: '全局正文。', scope: 'global' },
+  { agent: ovAgent },
+);
+const ovOther = await defs.get('memory_save').execute(
+  { title: '别的项目', summary: '只在别的项目里', body: '另一层的正文。', tags: ['别的'] },
+  { agent: { id: 'session-overview-other', cwd: ovOtherCwd, session: { id: 'session-overview-other', header: { cwd: ovOtherCwd } } } },
+);
+const ov = await call('/lite-memory/overview', { sessionId: 'session-overview' });
+assert.equal(ov.status, 200);
+assert.equal(ov.body.ok, true);
+assert.equal(ov.body.current.key, store.scopeOf(ovCwd).key);
+assert.equal(ov.body.current.label, path.basename(ovCwd));
+assert.equal(ov.body.current.evolution.enabled, false);
+assert.equal(ov.body.selected.key, ov.body.current.key);
+assert.equal(ov.body.selected.kind, 'project');
+assert.equal(ov.body.selected.evolution.enabled, false);
+assert.ok(Array.isArray(ov.body.selected.evolution.rules));
+assert.ok(ov.body.selected.records.some((row) => row.id === ovFirst.id && row.title === '开场先给结论'));
+assert.equal(ov.body.selected.records.some((row) => 'body' in row), false, '列表不带正文');
+assert.equal(ov.body.selected.stats.total, 2);
+assert.equal(ov.body.selected.stats.tags, 3);
+assert.equal(JSON.stringify(ov.body).includes('"dir"'), false, '不暴露内部目录');
+assert.equal(JSON.stringify(ov.body).includes(process.env.DSH_HOME), false);
+const ovKeys = ov.body.scopes.map((row) => row.key);
+assert.ok(ovKeys.includes(ov.body.current.key));
+assert.ok(ovKeys.includes(store.scopeOf(ovOtherCwd).key));
+assert.ok(ovKeys.includes('global'), '全局层总在列表里');
+
+// 切到别的项目只是换一面看，不写那个项目
+const ovOtherView = await call('/lite-memory/overview', { sessionId: 'session-overview', scopeKey: store.scopeOf(ovOtherCwd).key });
+assert.equal(ovOtherView.status, 200);
+assert.equal(ovOtherView.body.selected.key, store.scopeOf(ovOtherCwd).key);
+assert.deepEqual(ovOtherView.body.selected.records.map((row) => row.title), ['别的项目']);
+assert.equal(ovOtherView.body.selected.evolution.enabled, false, '别的项目也要给只读实验状态');
+assert.equal(ovOtherView.body.current.key, ov.body.current.key);
+const ovGlobal = await call('/lite-memory/overview', { sessionId: 'session-overview', scopeKey: 'global' });
+assert.equal(ovGlobal.status, 200);
+assert.equal(ovGlobal.body.selected.kind, 'global');
+assert.ok(ovGlobal.body.selected.records.some((row) => row.title === '观察全局'));
+
+// 详情按服务端枚举过的 scopeKey 取；内部路径、未知键一律不放行
+const ovBody = await call('/lite-memory/body', { sessionId: 'session-overview', id: ovFirst.id, scopeKey: ov.body.current.key });
+assert.equal(ovBody.status, 200);
+assert.equal(ovBody.body.body, '开场三句内给结论。');
+assert.equal(ovBody.body.scopeLabel, path.basename(ovCwd));
+const ovOtherBody = await call('/lite-memory/body', { sessionId: 'session-overview', id: ovOther.id, scopeKey: store.scopeOf(ovOtherCwd).key });
+assert.equal(ovOtherBody.status, 200);
+assert.equal(ovOtherBody.body.scopeLabel, path.basename(ovOtherCwd));
+assert.equal((await call('/lite-memory/body', { sessionId: 'session-overview', id: ovFirst.id, scopeKey: 'nope' })).status, 404);
+assert.equal((await call('/lite-memory/body', { sessionId: 'session-overview', id: ovFirst.id, scopeKey: '../x' })).status, 404);
+assert.equal((await call('/lite-memory/overview', {})).status, 400);
+assert.equal((await call('/lite-memory/overview', { sessionId: 'session-overview' }, { origin: 'http://evil.example' })).status, 403);
+const ovUnknownCwd = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-contract-overview-unknown-'));
+sessionCwds.set('session-overview-unknown', ovUnknownCwd);
+const ovUnconfirmedSaved = process.env.PATH;
+process.env.PATH = '';
+const ovUnconfirmed = await call('/lite-memory/overview', { sessionId: 'session-overview-unknown' });
+process.env.PATH = ovUnconfirmedSaved;
+assert.equal(ovUnconfirmed.status, 409);
+assert.equal(fs.existsSync(path.join(store.scopeOf(ovUnknownCwd).dir, 'state.json')), false);
+
+// 实验条目也画进图里，但只有面板能看见；普通读取面仍然拿不到
+state.transact(store.scopeOf(ovCwd), {}, (draft) => {
+  const row = draft.entries.find((entry) => entry.id === ovSecond.id);
+  row.origin = 'project_evolution';
+  row.maintenance = { ...(row.maintenance || {}), learning: { state: 'trial', source: 'evolution' } };
+  return { changed: true };
+});
+const ovExperimental = await call('/lite-memory/overview', { sessionId: 'session-overview' });
+assert.equal(ovExperimental.body.selected.stats.experimental, 1);
+assert.equal(ovExperimental.body.selected.records.find((row) => row.id === ovSecond.id).experimental, true);
+assert.equal(store.loadIndex(store.scopeOf(ovCwd), { allowExperimental: true }).entries.some((row) => row.id === ovSecond.id), true);
+
+// 归档不是死数字：总数诚实，列表单独取，正文还能按 id 打开
+state.transact(store.scopeOf(ovCwd), {}, (draft) => {
+  const row = draft.entries.find((entry) => entry.id === ovSecond.id);
+  row.status = 'archived';
+  return { changed: true };
+});
+const ovArchived = await call('/lite-memory/overview', { sessionId: 'session-overview' });
+assert.equal(ovArchived.body.selected.stats.archived, 1);
+assert.equal(ovArchived.body.selected.records.some((row) => row.id === ovSecond.id), false);
+assert.equal(ovArchived.body.selected.archived.some((row) => row.id === ovSecond.id), true);
+const ovArchivedBody = await call('/lite-memory/body', { sessionId: 'session-overview', id: ovSecond.id, scopeKey: ovArchived.body.selected.key });
+assert.equal(ovArchivedBody.status, 200);
+assert.equal(ovArchivedBody.body.status, 'archived');
+assert.equal(ovArchivedBody.body.body, '右侧留白。');
+
 console.log('contract.test.mjs: all passed');

package/test/control.test.mjs

@@ -0,0 +1,297 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+process.env.DSH_HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'lite-memory-control-'));
+const { apply } = await import('../index.js');
+const store = await import('../store.js');
+const state = await import('../state.js');
+
+const effect = (fn) => {
+  const dispose = fn();
+  return typeof dispose === 'function' ? dispose : () => {};
+};
+
+function boot() {
+  const defs = new Map();
+  const handlers = new Map();
+  const promptContexts = [];
+  const ctx = {
+    tools: { register: (def) => { defs.set(def.name, def); return () => {}; } },
+    effect,
+    inject: () => () => {},
+    get: (name) => (name === 'systemPrompt'
+      ? { context: (entry) => { promptContexts.push(entry); return () => {}; } }
+      : name === 'agents' ? { currentInitiator: () => null } : undefined),
+    on: (event, handler) => {
+      const list = handlers.get(event) || [];
+      list.push(handler);
+      handlers.set(event, list);
+      return () => {};
+    },
+  };
+  apply(ctx, { mode: 'adaptive' });
+  const provider = promptContexts.find((entry) => entry.name === 'lite-memory:recall');
+  const exec = (name, args, agent) => defs.get(name).execute(args, { agent });
+  const preStep = (payload, decision) => handlers.get('agent/pre-step').at(-1)(payload, async () => decision);
+  return { exec, preStep, text: (agent, signal) => provider.text({ agent, signal }), debug: globalThis.__liteMemoryRecall };
+}
+
+let seq = 0;
+const human = (body) => { seq += 1; return { role: 'user', id: `msg-${seq}`, source: { kind: 'user' }, content: [{ type: 'text', text: body }] }; };
+const enter = (...messages) => ({ kind: 'enter', messages });
+const mkdir = (label) => fs.mkdtempSync(path.join(os.tmpdir(), `lite-memory-control-${label}-`));
+const makeAgent = (id, dir) => ({ id, cwd: dir, session: { id: `session-${id}`, header: { cwd: dir } } });
+const save = (scope, fields) => store.upsert(scope, {
+  applicability: 'all_in_scope',
+  body: `正文：${fields.title}`,
+  resolution: 'distinct',
+  ...fields,
+  summary: fields.summary ?? `${fields.title}的摘要`,
+});
+const seedRule = (scope, title) => {
+  const saved = save(scope, { title, tags: ['口播'] });
+  const id = saved.record?.id ?? saved.id;
+  state.transact(scope, {}, (draft) => {
+    const row = draft.entries.find((entry) => entry.id === id);
+    row.origin = 'project_evolution';
+    row.current.conditions = [{ key: 'seriesId', value: '口播' }];
+    row.maintenance.learning = { state: 'active' };
+    return { changed: true };
+  });
+  return id;
+};
+const scopeOf = (dir) => store.scopeOf(dir);
+const toggle = (scope, enabled) => store.setMemoryEnabled(scope, enabled, { operationId: `op-${Math.random().toString(16).slice(2)}` });
+
+/* C01：总开关关闭后，自动注入、全局召回、检索、读取、写入、学习全部停。 */
+{
+  const dir = mkdir('off');
+  const scope = scopeOf(dir);
+  const globalSaved = save(store.globalScope(), { title: '全局写作偏好', tags: ['写作'] });
+  const globalId = globalSaved.record?.id ?? globalSaved.id;
+  save(scope, { title: '项目构建约定', tags: ['构建'] });
+  seedRule(scope, '口播开头');
+  assert.equal(store.setEvolution(scope, true, { operationId: 'evo-on' }).ok, true);
+  assert.equal(toggle(scope, false).ok, true);
+  assert.equal(store.controlStatus(scope).enabled, false);
+
+  const runtime = boot();
+  const agent = makeAgent('a-off', dir);
+  const sig = new AbortController().signal;
+  await runtime.preStep({ agent, signal: sig, turn: 't1' }, enter(human('按全局写作偏好来修构建脚本')));
+  assert.equal(runtime.text(agent, sig), '');
+  assert.equal(runtime.debug.preparedOf(agent), null);
+
+  const found = await runtime.exec('memory_search', { query: '写作 构建 口播开头' }, agent);
+  assert.equal(found.status, 'memory_disabled');
+  assert.equal(found.count, 0);
+  assert.ok(globalId);
+  assert.equal((await runtime.exec('memory_read', { id: globalId }, agent)).status, 'memory_disabled');
+  assert.equal((await runtime.exec('memory_forget', { id: globalId, mode: 'archive' }, agent)).mode, 'memory_disabled');
+  const suggested = await runtime.exec('memory_suggest', { title: '新偏好', summary: '一条偏好' }, agent);
+  assert.equal(suggested.asked, false);
+  const saved = await runtime.exec('memory_save', { title: '关闭后写入', summary: '应当拒绝', body: '不该落盘' }, agent);
+  assert.equal(saved.changed, false);
+  assert.equal(saved.reason, 'memory_disabled');
+  assert.equal(saved.id, '');
+}
+
+/* C02：关闭期间所有写入入口都拒绝，自进化不能绕过总开关打开。 */
+{
+  const dir = mkdir('write');
+  const scope = scopeOf(dir);
+  assert.equal(toggle(scope, false).ok, true);
+  assert.equal(store.setEvolution(scope, true, { operationId: 'evo-blocked' }).ok, false);
+  const saved = store.saveEntry(scope, { title: '一条项目规范', summary: '普通摘要', body: '正文', kind: 'convention', scope: 'project', durability: 'durable' });
+  assert.equal(saved.reasonCode, 'memory_disabled');
+  const task = store.saveTaskState(scope, { version: 1, sessions: {}, episodes: {}, defaults: null, revision: 1 }, { operationId: 'task-blocked' });
+  assert.equal(task.ok, false);
+  const committed = store.commitLearning(scope, { title: '学习规则', summary: '摘要', body: '正文' }, {}, { operationId: 'learn-blocked' });
+  assert.equal(committed.ok, false);
+  const run = store.setEvolution(scope, false, { operationId: 'evo-off' });
+  assert.equal(run.ok, false);
+  assert.equal(run.code, 'memory_disabled');
+  assert.equal(store.controlStatus(scope).enabled, false);
+}
+
+/* C03：关一个项目不影响另一个；重新打开记忆后自进化仍保持关闭。 */
+{
+  const dirA = mkdir('iso-a');
+  const dirB = mkdir('iso-b');
+  const scopeA = scopeOf(dirA);
+  const scopeB = scopeOf(dirB);
+  save(scopeB, { title: 'B 项目构建约定', tags: ['构建', '脚本'] });
+  seedRule(scopeB, '口播开头');
+  assert.equal(store.setEvolution(scopeB, true, { operationId: 'evo-b' }).ok, true);
+  assert.equal(toggle(scopeA, false).ok, true);
+  assert.equal(store.evolutionStatus(scopeB).enabled, true);
+  assert.equal(store.controlStatus(scopeB).enabled, true);
+
+  const runtime = boot();
+  const agentB = makeAgent('b-live', dirB);
+  const sigB = new AbortController().signal;
+  await runtime.preStep({ agent: agentB, signal: sigB, turn: 't1' }, enter(human('按项目构建约定改脚本')));
+  assert.match(runtime.text(agentB, sigB), /B 项目构建约定/);
+
+  toggle(scopeB, false);
+  assert.equal(store.evolutionStatus(scopeB).enabled, false);
+  assert.equal(store.evolutionStatus(scopeB).configuredEnabled, false);
+  toggle(scopeB, true);
+  assert.equal(store.evolutionStatus(scopeB).enabled, false);
+  assert.equal(store.setEvolution(scopeB, true, { operationId: 'evo-b-again' }).ok, true);
+  assert.equal(store.evolutionStatus(scopeB).enabled, true);
+}
+
+/* C04：切换总开关让旧任务上下文立即失效，不拿关闭前的绑定继续注入。 */
+{
+  const dir = mkdir('stale');
+  const scope = scopeOf(dir);
+  seedRule(scope, '口播开头');
+  assert.equal(store.setEvolution(scope, true, { operationId: 'evo-stale' }).ok, true);
+  const runtime = boot();
+  const agent = makeAgent('a-stale', dir);
+  const sig = new AbortController().signal;
+  await runtime.preStep({ agent, signal: sig, turn: 't1' }, enter(human('这期口播开头怎么改')));
+  const held = runtime.debug.windowOf(agent).experiment;
+  assert.ok(held && held.contextId);
+  toggle(scope, false);
+  toggle(scope, true);
+  const stale = await runtime.exec('memory_search', { query: '口播开头', contextId: held.contextId }, agent);
+  assert.equal(stale.status !== 'ok', true);
+  assert.equal((await runtime.exec('memory_search', { query: '口播开头' }, agent)).status, 'ok');
+}
+
+/* C05：关闭保留候选、试用、结果与整理回执；重开记忆后自进化仍是关闭。 */
+{
+  const dir = mkdir('preserve');
+  const scope = scopeOf(dir);
+  const id = seedRule(scope, '口播开头');
+  assert.equal(store.setEvolution(scope, true, { operationId: 'evo-preserve' }).ok, true);
+  const before = store.learningSnapshot(scope);
+  assert.equal(before.counts.active, 1);
+  assert.equal(toggle(scope, false).ok, true);
+  const closed = store.learningSnapshot(scope);
+  assert.equal(closed.enabled, false);
+  assert.equal(closed.rules.length, before.rules.length);
+  assert.equal(closed.counts.active, 1);
+  assert.equal(toggle(scope, true).ok, true);
+  const reopened = store.learningSnapshot(scope);
+  assert.equal(reopened.enabled, false);
+  assert.equal(reopened.counts.active, 1);
+  assert.equal(store.evolutionStatus(scope).configuredEnabled, false);
+  assert.equal(store.setEvolution(scope, true, { operationId: 'evo-resume' }).ok, true);
+  assert.equal(store.learningSnapshot(scope).counts.active, 1);
+  assert.ok(id);
+}
+
+/* C06：关闭期间管理面写操作一律拒绝，只读快照不写盘。 */
+{
+  const dir = mkdir('managed-off');
+  const scope = scopeOf(dir);
+  const id = seedRule(scope, '口播开头');
+  assert.equal(store.setEvolution(scope, true, { operationId: 'evo-managed' }).ok, true);
+  toggle(scope, false);
+  const file = state.stateFiles(scope).current;
+  const before = fs.readFileSync(file);
+  const snapshot = store.learningSnapshot(scope);
+  const rule = snapshot.rules[0];
+  assert.equal(rule.id, id);
+  assert.equal(Buffer.compare(before, fs.readFileSync(file)), 0);
+  for (const action of ['pin', 'pause', 'resume', 'delete', 'undo', 'adopt', 'edit']) {
+    let result;
+    if (action === 'pin') result = store.pinLearningRule(scope, id, { pinned: true, expectedRevision: rule.revision });
+    if (action === 'pause') result = store.pauseLearningRules(scope, [id], { operationId: 'pause-off' });
+    if (action === 'resume') result = store.resumeLearningRule(scope, id);
+    if (action === 'delete') result = store.removeLearningRule(scope, id, { expectedRevision: rule.revision });
+    if (action === 'undo') result = store.undoLearningChange(scope, id, { expectedRevision: rule.revision });
+    if (action === 'adopt') result = store.adoptLearningRule(scope, id, { expectedRevision: rule.revision });
+    if (action === 'edit') result = store.editLearningRule(scope, id, { expectedRevision: rule.revision, body: '改过的正文' });
+    assert.equal(result.ok, false, action);
+    assert.equal(result.code, 'memory_disabled', action);
+  }
+  assert.equal(Buffer.compare(before, fs.readFileSync(file)), 0);
+}
+
+/* C07：采纳把候选转为生效；编辑只保存并留上一版，不改状态以外的东西。 */
+{
+  const dir = mkdir('adopt');
+  const scope = scopeOf(dir);
+  const id = seedRule(scope, '口播开头');
+  const first = store.learningSnapshot(scope).rules[0];
+  const edited = store.editLearningRule(scope, id, { expectedRevision: first.revision, body: '开头两句内给结论。', title: '口播结论前置' });
+  assert.equal(edited.ok, true);
+  const afterEdit = store.learningSnapshot(scope).rules[0];
+  assert.equal(afterEdit.state, 'trial');
+  assert.equal(afterEdit.body, '开头两句内给结论。');
+  assert.equal(afterEdit.title, '口播结论前置');
+  assert.equal(afterEdit.learning.versions.length, 1);
+  const adopted = store.adoptLearningRule(scope, id, { expectedRevision: afterEdit.revision });
+  assert.equal(adopted.ok, true);
+  const afterAdopt = store.learningSnapshot(scope).rules[0];
+  assert.equal(afterAdopt.state, 'active');
+  assert.equal(afterAdopt.body, '开头两句内给结论。');
+  assert.equal(afterAdopt.title, '口播结论前置');
+}
+
+/* C07b：只改标题不动正文时保留生效状态与学习依据。 */
+{
+  const dir = mkdir('title-only');
+  const scope = scopeOf(dir);
+  const id = seedRule(scope, '口播开头');
+  state.transact(scope, {}, (draft) => {
+    const row = draft.entries.find((entry) => entry.id === id);
+    row.maintenance.learning = { state: 'active', evidence: [{ text: '三次口播都先改开头' }] };
+    return { changed: true };
+  });
+  const first = store.learningSnapshot(scope).rules[0];
+  const edited = store.editLearningRule(scope, id, { expectedRevision: first.revision, title: '口播开头重命名' });
+  assert.equal(edited.ok, true);
+  const after = store.learningSnapshot(scope).rules[0];
+  assert.equal(after.state, 'active');
+  assert.equal(after.learning.evidence.length, 1);
+  assert.equal(after.title, '口播开头重命名');
+}
+
+/* C08：关闭保留已消耗额度与默认绑定，重开后仍按原额度限额。 */
+{
+  const dir = mkdir('preserve-quota');
+  const scope = scopeOf(dir);
+  assert.equal(store.setEvolution(scope, true, { operationId: 'evo-quota' }).ok, true);
+  const defaults = { taskKind: 'video', seriesId: '口播' };
+  assert.equal(store.saveTaskState(scope, { version: 1, sessions: {}, episodes: {}, defaults, revision: 1 }, { operationId: 'defaults' }).ok, true);
+  assert.equal(store.beginLearningAttempt(scope, { episodeId: 'ep-preserve', operationId: 'a1' }).ok, true);
+  assert.equal(store.beginLearningAttempt(scope, { episodeId: 'ep-preserve', operationId: 'a2' }).ok, true);
+  assert.equal(store.beginLearningAttempt(scope, { episodeId: 'ep-preserve', operationId: 'a3' }).ok, false);
+  toggle(scope, false);
+  toggle(scope, true);
+  assert.deepEqual(store.taskState(scope).defaults, { ...defaults, confirmedBy: 'user', confirmedAt: '' });
+  assert.equal(store.setEvolution(scope, true, { operationId: 'evo-quota-again' }).ok, true);
+  const limited = store.beginLearningAttempt(scope, { episodeId: 'ep-preserve', operationId: 'a4' });
+  assert.equal(limited.ok, false);
+  assert.equal(limited.reason, 'episode_limit');
+}
+
+/* C09：同一项目两个会话都已准备内容，关闭后两边都立即失效。 */
+{
+  const dir = mkdir('two-sessions');
+  const scope = scopeOf(dir);
+  seedRule(scope, '口播开头');
+  assert.equal(store.setEvolution(scope, true, { operationId: 'evo-two' }).ok, true);
+  const runtime = boot();
+  const a1 = makeAgent('two-1', dir);
+  const a2 = makeAgent('two-2', dir);
+  const sig = new AbortController().signal;
+  await runtime.preStep({ agent: a1, signal: sig, turn: 't1' }, enter(human('这期口播开头怎么改')));
+  await runtime.preStep({ agent: a2, signal: sig, turn: 't1' }, enter(human('这期口播开头怎么改')));
+  assert.match(runtime.text(a1, sig), /口播开头/);
+  assert.match(runtime.text(a2, sig), /口播开头/);
+  toggle(scope, false);
+  assert.equal(runtime.text(a1, sig), '');
+  assert.equal(runtime.text(a2, sig), '');
+  assert.equal(runtime.debug.preparedOf(a1).text, '');
+  assert.equal(runtime.debug.preparedOf(a2).text, '');
+}
+
+console.log('control.test.mjs: all passed');