dsh-lite-memory 0.16.2 → 0.17.0

package/test/learning.test.mjs

@@ -148,10 +148,31 @@ test('P00 作品验收不直接形成长期规则', () => {
   assert.equal(parsed({ ...NEW_CHANGE, feedbackType: 'artifact_accept' }).ok, false);
 });
 
-test('P00 只有已绑定作品的人类消息进入候选', () => {
+test('P00 长期声明本身就算规范变化', () => {
+  const cue = learning.classifyFeedback('这个项目默认用 pnpm');
+  assert.equal(cue.worth, true);
+  assert.equal(cue.type, 'spec_change');
+  assert.equal(cue.explicitLongTerm, true);
+});
+
+test('P00 未绑定的作品可以回落到项目候选', () => {
   const human = (id, text) => ({ id, source: { kind: 'user' }, content: [{ type: 'text', text }] });
   const base = { episodeId: 'ep_x', status: 'active', updatedAt: '2026-01-01T00:00:00.000Z' };
   assert.equal(learning.candidateFrom({ messages: [human('m1', '以后开头先给结论')], anchor: { ...base, status: 'unbound' } }), null);
+  const projectCandidate = learning.candidateFrom({
+    messages: [human('m2', '以后这个项目默认用 pnpm')],
+    anchor: { ...base, status: 'unbound' }, sessionId: 's', projectId: 'p',
+  });
+  assert.equal(projectCandidate.scope, 'project');
+  assert.equal(projectCandidate.episodeId, '');
+  assert.equal(projectCandidate.expectedTarget.scope, 'project');
+  const correction = learning.candidateFrom({
+    messages: [human('m3', '这里改成蓝色')], anchor: { ...base, status: 'unbound' }, projectId: 'p',
+  });
+  assert.equal(correction.scope, 'project');
+  assert.equal(learning.candidateFrom({
+    messages: [human('m4', '这次这里改成蓝色')], anchor: { ...base, status: 'unbound' }, projectId: 'p',
+  }), null);
   assert.equal(learning.candidateFrom({ messages: [{ id: 'a1', source: { kind: 'assistant' }, content: '收到' }], anchor: base }), null);
   const candidate = learning.candidateFrom({ messages: [human('m1', '以后开头都先给结论，别再铺垫')], anchor: base, sessionId: 's', projectId: 'p' });
   assert.equal(candidate.episodeId, 'ep_x');
@@ -189,6 +210,18 @@ test('B01 调用输入不超过 8 KiB 且只有本地引用', () => {
   assert.doesNotMatch(input.system, /工具调用/);
 });
 
+test('B01 项目层整理输入不带作品身份', () => {
+  const input = learning.buildCallInput({
+    projectId: 'p',
+    episodeId: '',
+    feedback: { text: '以后这个项目默认用 pnpm', messageIds: ['m1'], cue: { type: 'spec_change', explicitLongTerm: true }, scope: 'project' },
+    rules: [],
+  });
+  assert.match(input.prompt, /"scope":"project"/);
+  assert.doesNotMatch(input.prompt, /"episodeId"/);
+  assert.match(input.system, /待确认候选/);
+});
+
 test('B01 截断、工具调用、额外字段整批拒绝', () => {
   assert.equal(learning.parseOutput('{"changes":[{"target":"new"', { finish: { kind: 'stop' } }).ok, false);
   assert.equal(learning.parseOutput('<tool>memory_save</tool>', { finish: { kind: 'stop' } }).ok, false);
@@ -433,7 +466,7 @@ test('P06 作品版本变了旧整理整批作废', () => {
   store.saveTaskState(scope, later.tasks, { operationId: 'tasks_later' });
   const stale = commitNew(scope, grown, started, NEW_CHANGE, { now: Date.now() + 2000 });
   assert.equal(stale.ok, false);
-  assert.match(stale.reason, /换到别的作品|改过这期|失效/);
+  assert.match(stale.reason, /换到别的作品|改过这期|失效|没采用/);
   assert.equal(ruleRows(scope).length, 0);
 });
 
@@ -617,6 +650,29 @@ test('B06 失败调用只留回执不写正文', () => {
   assert.equal(receipt.reason, '整理没有返回内容');
 });
 
+test('P07 项目层候选无需作品也能落规则', () => {
+  const scope = fresh('project-rule');
+  enable(scope);
+  const started = store.beginLearningAttempt(scope, { episodeId: '', operationId: 'start_project' });
+  assert.equal(started.ok, true, started.reason);
+  const check = parsed(NEW_CHANGE);
+  assert.equal(check.ok, true, check.reason);
+  const result = store.commitLearning(scope, {
+    operationId: 'learn_project',
+    epoch: started.epoch,
+    episodeId: '',
+    projectId: scope.key,
+    sessionId: 's1',
+    messageIds: ['m1'],
+    changes: check.changes,
+    preparedTargets: [],
+  });
+  assert.equal(result.ok, true, result.reason);
+  assert.equal(ruleRows(scope).length, 1);
+  assert.equal(ruleRows(scope)[0].ownerProjectId, scope.key);
+  assert.equal(ruleRows(scope)[0].learning.state, 'trial');
+});
+
 test('P07 两条同批变化一次写入', () => {
   const scope = fresh('two-changes');
   enable(scope);
@@ -769,4 +825,430 @@ test('D10 效果摘要只算最近 64 条，未知用量不补零', () => {
   assert.equal(after.outputTokens, null);
 });
 
+test('L01 没有作品绑定的长期项目要求仍是待确认候选', () => {
+  const message = (id, text) => ({ id, source: { kind: 'user' }, content: [{ type: 'text', text }] });
+  const candidate = learning.candidateFrom({
+    messages: [message('m1', '以后数据库查询都改成参数化查询')],
+    anchor: null,
+    sessionId: 's1',
+    projectId: 'proj_a',
+    now: 1000,
+  });
+  assert.ok(candidate);
+  assert.equal(candidate.scope, 'project');
+  assert.equal(candidate.state, 'pending');
+  assert.equal(candidate.episodeId, '');
+  assert.equal(candidate.seriesId, '');
+  assert.deepEqual(candidate.messageIds, ['m1']);
+  assert.equal(candidate.expectedTarget.scope, 'project');
+  assert.equal(candidate.expectedTarget.projectId, 'proj_a');
+  assert.equal(candidate.expectedTarget.applicability, 'unresolved');
+  assert.match(candidate.sourceExcerpt, /参数化查询/);
+  /** 跨项目一律不接收；没有项目身份的裸反馈也不进候选。 */
+  assert.equal(learning.candidateFrom({
+    messages: [message('m1', '以后数据库查询都改成参数化查询')],
+    anchor: { episodeId: 'e0', projectId: 'proj_b', status: 'active' },
+    projectId: 'proj_a',
+  }), null);
+  assert.equal(learning.candidateFrom({ messages: [message('m1', '以后都参数化查询')] }), null);
+  /** 短期例外即使没绑定作品也不当项目规范。 */
+  assert.equal(learning.candidateFrom({
+    messages: [message('m1', '这次开头先别放字幕')],
+    anchor: null,
+    projectId: 'proj_a',
+  }), null);
+  /** 有作品绑定仍走作品作用域，且不把项目当成单条栏目。 */
+  const bound = learning.candidateFrom({
+    messages: [message('m1', '以后字幕都改成底部安全区')],
+    anchor: { episodeId: 'e1', projectId: 'proj_a', status: 'active', taskKind: 'video', seriesId: 's1' },
+    sessionId: 's1',
+    projectId: 'proj_a',
+  });
+  assert.equal(bound.scope, 'episode');
+  assert.equal(bound.episodeId, 'e1');
+  assert.equal(bound.expectedTarget.episodeId, 'e1');
+  assert.equal(bound.seriesId, 's1');
+});
+
+test('L02 先按相关性选规则，再截断，字幕规则不会被挤掉', () => {
+  const rows = [];
+  for (let index = 0; index < 6; index += 1) {
+    rows.push({
+      id: `mem_a${index}`, topicKey: `配色${index}`, title: `配色${index}`,
+      body: `配色方案${index}`, summary: `配色经验${index}`,
+      conditions: [], applicability: 'all_in_scope',
+      learning: { state: 'active' }, updated: '2026-01-01T00:00:00.000Z',
+    });
+  }
+  rows.push({
+    id: 'mem_sub', topicKey: '字幕样式', title: '字幕样式', body: '字幕放底部安全区',
+    summary: '字幕经验', conditions: [{ key: 'seriesId', value: '字幕' }],
+    applicability: 'conditional', learning: { state: 'trial' }, updated: '2025-01-01T00:00:00.000Z',
+  });
+  rows.push({
+    id: 'mem_old', topicKey: '标题', title: '标题', body: '标题要短',
+    summary: '标题经验', conditions: [], applicability: 'all_in_scope',
+    learning: { state: 'pending' }, updated: '2025-01-01T00:00:00.000Z',
+  });
+  rows.push({
+    id: 'mem_bgm', topicKey: '配乐', title: '配乐', body: '配乐低一点',
+    summary: '配乐经验', conditions: [], applicability: 'all_in_scope',
+    learning: { state: 'active' }, updated: '2025-01-01T00:00:00.000Z',
+  });
+  rows.push({
+    id: 'mem_safe', topicKey: '字幕安全区', title: '字幕安全区', body: '字幕不要贴边',
+    summary: '字幕留安全区', conditions: [{ key: 'seriesId', value: '字幕' }],
+    applicability: 'conditional', learning: { state: 'active' }, updated: '2024-01-01T00:00:00.000Z',
+  });
+  const context = { query: '字幕位置太低，以后字幕都放底部安全区', dimensions: ['字幕'] };
+  const ranked = learning.rankRules(rows, context);
+  assert.equal(ranked[0].id, 'mem_safe');
+  assert.equal(ranked[1].id, 'mem_sub');
+  const selected = learning.selectRules(rows, { ...context, limit: 6 });
+  assert.equal(selected.length, 6);
+  assert.equal(selected[0].id, 'mem_safe');
+  assert.equal(selected[1].id, 'mem_sub');
+  assert.deepEqual(learning.rankRules(rows, context).map((row) => row.id), ranked.map((row) => row.id));
+  /** buildCallInput 的输入上限是 6，但字幕规则必须在里面。 */
+  const input = learning.buildCallInput({
+    projectId: 'proj', episodeId: 'e1', taskKind: 'video', seriesId: '字幕', phase: 'p1',
+    feedback: { text: '字幕位置太低，以后字幕都放底部安全区', cue: { dimension: '字幕' }, messageIds: ['m1'] },
+    rules: rows, ranges: RANGES,
+  });
+  assert.ok(input.rules.length <= 6);
+  const ids = new Set(Object.values(input.refs.rules));
+  assert.ok(ids.has('mem_safe'));
+  assert.ok(ids.has('mem_sub'));
+});
+
+test('L03 反馈类型限制动作：例外/检查点/认可不能写规范', () => {
+  const rules = [{ ref: 'r0', id: 'mem_1', revision: 2, conditions: [{ key: 'seriesId', value: '口播' }] }];
+  const refs = { feedback: { u0: 'm1' }, rules: { r0: 'mem_1' } };
+  const check = (change) => learning.validateChange(change, { refs, rules, ranges: RANGES });
+  assert.equal(check({ ...NEW_CHANGE, target: 'new', feedbackType: 'task_exception' }).ok, false);
+  assert.equal(check({ ...NEW_CHANGE, target: 'new', feedbackType: 'unclear' }).ok, false);
+  const checkpoint = check({ target: 'r0', feedbackType: 'execution_miss', currentText: '发布前核对字幕安全区', evidence: ['u0'] });
+  assert.equal(checkpoint.ok, true, checkpoint.reason);
+  const rewritten = check({ target: 'r0', feedbackType: 'execution_miss', currentText: '新正文', title: '新标题' });
+  assert.equal(rewritten.ok, false);
+  const newAccept = check({ target: 'new', feedbackType: 'aspect_accept', topicKey: '字幕', currentText: '字幕放底部' });
+  assert.equal(newAccept.ok, false);
+  const accept = check({ target: 'r0', feedbackType: 'aspect_accept', conditions: [{ key: 'seriesId', value: '口播' }], evidence: ['u0'] });
+  assert.equal(accept.ok, true, accept.reason);
+  const mismatched = check({ target: 'r0', feedbackType: 'aspect_accept', conditions: [{ key: 'seriesId', value: '字幕' }] });
+  assert.equal(mismatched.ok, false);
+  assert.equal(mismatched.reason, '认可条件与目标规则不一致');
+  const rewrite = check({ target: 'r0', feedbackType: 'aspect_accept', currentText: '顺手把正文改了' });
+  assert.equal(rewrite.ok, false);
+  /** 同类型走 nextLearningState 也不抬状态。 */
+  const active = { id: 'mem_1', revision: 2, topicKey: '字幕', body: '字幕放底部', applicability: 'conditional', conditions: [{ key: 'seriesId', value: '口播' }], learning: { state: 'active', supportedEpisodeIds: ['e1', 'e2'], evidence: [] } };
+  for (const feedbackType of ['execution_miss', 'aspect_accept', 'artifact_accept', 'task_exception', 'unclear']) {
+    const next = learning.nextLearningState({ existing: active, change: { id: 'mem_1', feedbackType }, evidence: { episodeId: 'e3' }, now: 1000 });
+    assert.equal(next.state, 'active', feedbackType);
+    assert.deepEqual(next.supportedEpisodeIds, ['e1', 'e2'], feedbackType);
+    const created = learning.nextLearningState({ existing: null, change: { feedbackType }, evidence: { episodeId: 'e1' }, now: 1000 });
+    assert.notEqual(created.state, 'active', feedbackType);
+  }
+});
+
+test('L03b 明确长期要求整理为空时也留下规则', () => {
+  const change = learning.pendingChangeFrom({ text: '以后这个项目默认用 pnpm。', cue: { explicitLongTerm: true } });
+  assert.equal(change.target, 'new');
+  assert.equal(change.feedbackType, 'spec_change');
+  assert.equal(change.currentText, '以后这个项目默认用 pnpm。');
+  assert.equal(change.evidence[0], 'u0');
+  const check = learning.validateChange(change, { refs: { feedback: { u0: 'm1' }, rules: {} }, rules: [], ranges: RANGES });
+  assert.equal(check.ok, true, check.reason);
+  assert.equal(learning.pendingChangeFrom({ text: '   ' }), null);
+});
+
+test('L04 先算目标状态再查配额，过期候选可恢复', () => {
+  const base = { existing: null, evidence: { episodeId: 'e1', messageIds: ['m1'], sourceExcerpt: '以后都用参数化查询' }, pending: 12, rules: 0, now: 1000 };
+  const active = learning.admitChange({ ...base, change: NEW_CHANGE, explicitLongTerm: true });
+  assert.equal(active.ok, true, active.reason);
+  assert.equal(active.learning.state, 'active');
+  assert.equal(active.merged.current.body, NEW_CHANGE.currentText);
+  const candidate = learning.admitChange({
+    ...base,
+    pending: 12,
+    change: { ...NEW_CHANGE, conditions: [], applicability: 'unresolved' },
+  });
+  assert.equal(candidate.ok, false);
+  assert.equal(candidate.reason, '待确认候选已经到上限');
+  const full = learning.admitChange({ ...base, rules: learning.LIMITS.rules, pending: 0, change: NEW_CHANGE });
+  assert.equal(full.ok, false);
+  assert.equal(full.reason, '项目实验规则已经到上限');
+  const existing = {
+    id: 'mem_1', revision: 3, topicKey: '口播开头', body: '开头三句内给结论。',
+    applicability: 'conditional', conditions: [{ key: 'seriesId', value: '口播' }],
+    learning: {
+      state: 'trial',
+      specDigest: learning.specDigestOf({ topicKey: '口播开头', body: '开头三句内给结论。', applicability: 'conditional', conditions: [{ key: 'seriesId', value: '口播' }] }),
+      supportedEpisodeIds: [],
+      evidence: [],
+    },
+  };
+  const update = learning.admitChange({
+    existing, change: { ...NEW_CHANGE, target: 'r0' }, evidence: { episodeId: 'e2' }, pending: 99, rules: 99, now: 1000,
+  });
+  assert.equal(update.ok, true, update.reason);
+  assert.equal(update.learning.state, 'trial');
+  /** 过期待确认既不是永久候选，也不该被删；能重新唤起，且不占有效名额。 */
+  const stale = { id: 'mem_stale', origin: 'project_evolution', learning: { state: 'pending', createdAt: new Date(1000).toISOString() } };
+  const now = 1000 + learning.LIMITS.trialMs + 1000;
+  assert.equal(learning.candidateExpired(stale.learning, now), true);
+  assert.equal(learning.pendingCount([stale], now), 0);
+  assert.equal(learning.pendingCount([stale], 1000), 1);
+  const plan = learning.lifecycle([stale], now);
+  assert.deepEqual(plan.purge, []);
+  assert.deepEqual(plan.recoverable, ['mem_stale']);
+  const revived = learning.reviveCandidate(stale.learning, { now });
+  assert.equal(revived.state, 'pending');
+  assert.equal(learning.candidateExpired(revived, now), false);
+});
+
+test('L05 规范或目标变了旧证据清零，来源与版本绑定留在规则上', () => {
+  const conditions = [{ key: 'seriesId', value: '口播' }];
+  const body = '开头三句内给结论。';
+  const existing = {
+    id: 'mem_1', revision: 4, topicKey: '口播开头', title: '口播开头', body,
+    applicability: 'conditional', conditions,
+    learning: {
+      state: 'active', specDigest: learning.specDigestOf({ topicKey: '口播开头', body, applicability: 'conditional', conditions }),
+      supportedEpisodeIds: ['e1', 'e2'],
+      evidence: [{ episodeId: 'e1' }, { episodeId: 'e2' }],
+      samples: [{ episodeId: 'e1', dimension: '字幕' }],
+    },
+  };
+  const evidence = { episodeId: 'e3', messageIds: ['m1', 'm2', 'm3', 'm4'], sourceExcerpt: '原始反馈：以后开头先给结论' };
+  const changed = learning.nextLearningState({
+    existing,
+    change: { id: 'mem_1', currentText: '开头五句内给结论。', feedbackType: 'spec_change' },
+    evidence: { ...evidence, explicitLongTerm: true },
+    specChanged: true,
+    now: 2000,
+  });
+  assert.deepEqual(changed.supportedEpisodeIds, ['e3']);
+  assert.equal(changed.evidence.length, 1);
+  assert.equal(changed.evidenceResetReason, 'spec_changed');
+  assert.equal(changed.samples, undefined);
+  assert.equal(changed.sourceExcerpt, evidence.sourceExcerpt);
+  assert.deepEqual(changed.binding.messageIds, ['m2', 'm3', 'm4']);
+  assert.equal(changed.binding.targetId, 'mem_1');
+  assert.equal(changed.binding.baseRevision, 4);
+  assert.equal(changed.state, 'active');
+  /** 没有规范变化时保留证据，只追加本次作品。 */
+  const kept = learning.nextLearningState({
+    existing,
+    change: { id: 'mem_1', currentText: body, feedbackType: 'spec_change' },
+    evidence: { episodeId: 'e9', sourceExcerpt: '补充' },
+    specChanged: false,
+    now: 2000,
+  });
+  assert.deepEqual(kept.supportedEpisodeIds, ['e1', 'e2', 'e9']);
+  assert.equal(kept.evidenceResetReason, undefined);
+  /** 目标对象换了也清零。 */
+  const retargeted = learning.nextLearningState({
+    existing,
+    change: { id: 'mem_2', feedbackType: 'spec_change' },
+    evidence: { episodeId: 'e3' },
+    specChanged: false,
+    now: 2000,
+  });
+  assert.deepEqual(retargeted.supportedEpisodeIds, ['e3']);
+  assert.equal(retargeted.evidenceResetReason, 'target_changed');
+});
+
+test('L06 运行上下文只认传入身份，未绑定的 episodeId 不挡项目候选', () => {
+  const message = (id, text) => ({ id, source: { kind: 'user' }, content: [{ type: 'text', text }] });
+  const messages = [message('m1', '以后数据库查询都改成参数化查询')];
+  const runtime = learning.runtimeContextOf({
+    projectId: 'proj_a',
+    sessionId: 's1',
+    requestId: 'req_1',
+    anchor: { episodeId: 'e1', status: 'active', projectId: 'proj_a', taskKind: 'video', seriesId: '口播', phase: 'script' },
+  });
+  assert.deepEqual(
+    [runtime.projectId, runtime.sessionId, runtime.requestId, runtime.episodeId, runtime.bound],
+    ['proj_a', 's1', 'req_1', 'e1', true],
+  );
+  const unbound = learning.runtimeContextOf({ projectId: 'proj_a', anchor: { episodeId: 'e9', status: 'unbound', projectId: 'proj_a' } });
+  assert.equal(unbound.bound, false);
+  assert.equal(unbound.episodeId, 'e9');
+  /** 未绑定但任务里留着 episodeId：仍按项目候选收集，而不是「绑定失效」整条丢掉。 */
+  for (const anchorRow of [
+    { episodeId: 'e9', status: 'unbound', projectId: 'proj_a' },
+    { episodeId: 'e9', projectId: 'proj_a' },
+    { episodeId: 'e9', status: 'paused', projectId: 'proj_a' },
+  ]) {
+    const candidate = learning.candidateFrom({ messages, anchor: anchorRow, projectId: 'proj_a', sessionId: 's1', now: 1000 });
+    assert.ok(candidate, JSON.stringify(anchorRow));
+    assert.equal(candidate.scope, 'project', JSON.stringify(anchorRow));
+    assert.equal(candidate.episodeId, '');
+    assert.equal(candidate.projectId, 'proj_a');
+  }
+  /** 上下文之外的任何身份都不补：没传项目就是没有。 */
+  assert.equal(learning.runtimeContextOf({ anchor: { episodeId: 'e1', status: 'active' } }).projectId, '');
+  assert.equal(learning.candidateFrom({ messages }), null);
+});
+
+test('L07 sourceExcerpt 从候选到调用输入到兜底变化全程不丢', () => {
+  const message = (id, text) => ({ id, source: { kind: 'user' }, content: [{ type: 'text', text }] });
+  const text = '以后字幕都改成底部安全区，别再顶到画面中间';
+  const candidate = learning.candidateFrom({
+    messages: [message('m1', text), message('m2', '这期先这样')],
+    anchor: { episodeId: 'e1', status: 'active', projectId: 'proj_a' },
+    projectId: 'proj_a',
+    sessionId: 's1',
+    now: 1000,
+  });
+  assert.ok(candidate);
+  assert.match(candidate.sourceExcerpt, /底部安全区/);
+  const input = learning.buildCallInput({
+    projectId: 'proj_a',
+    episodeId: 'e1',
+    feedback: candidate,
+    rules: [],
+    ranges: RANGES,
+  });
+  assert.equal(input.overLimit, undefined);
+  assert.equal(input.sourceExcerpt, candidate.sourceExcerpt);
+  assert.deepEqual(input.messageIds, ['m1', 'm2']);
+  const rendered = JSON.parse(input.prompt);
+  assert.equal(rendered.feedback.sourceExcerpt, candidate.sourceExcerpt);
+  assert.deepEqual(rendered.feedback.messageIds, ['m1', 'm2']);
+  assert.deepEqual(input.refs.feedback, { u0: 'm1' });
+  /** 整理器返回空时的兜底变化也带着同一段来源。 */
+  const change = learning.pendingChangeFrom(candidate);
+  assert.equal(change.sourceExcerpt, candidate.sourceExcerpt);
+  const checked = learning.validateChange(change, { refs: input.refs, rules: [], ranges: RANGES });
+  assert.equal(checked.ok, true, checked.reason);
+  assert.equal(checked.change.sourceExcerpt, candidate.sourceExcerpt);
+  assert.equal(learning.pendingChangeFrom({ text: '   ' }), null);
+});
+
+test('L08 admissionOf 统一收集与展示，启发式推断不等于用户确认', () => {
+  const message = (id, text) => ({ id, source: { kind: 'user' }, content: [{ type: 'text', text }] });
+  const bound = learning.candidateFrom({
+    messages: [message('m1', '以后字幕都改成底部安全区')],
+    anchor: { episodeId: 'e1', status: 'active', projectId: 'proj_a', taskKind: 'video' },
+    projectId: 'proj_a',
+    sessionId: 's1',
+    now: 1000,
+  });
+  for (const purpose of ['collect', 'display']) {
+    const admission = learning.admissionOf(bound, {
+      projectId: 'proj_a',
+      sessionId: 's1',
+      anchor: { episodeId: 'e1', status: 'active', projectId: 'proj_a' },
+    }, purpose);
+    assert.equal(admission.ok, true, admission.reason);
+    assert.equal(admission.scope, 'episode');
+    assert.equal(admission.episodeId, 'e1');
+    assert.equal(admission.confirmed, false);
+    assert.equal(admission.requiresUserConfirmation, true);
+    assert.equal(admission.persistence, 'project_candidate');
+    assert.equal(admission.visibility, 'candidate');
+  }
+  /** 明确长期要求也只是候选：用户说过“以后”，不等于点过“记住”。 */
+  const longTerm = learning.candidateFrom({
+    messages: [message('m1', '以后数据库查询都改成参数化查询')],
+    anchor: null,
+    projectId: 'proj_a',
+    now: 1000,
+  });
+  assert.equal(learning.admissionOf(longTerm, { projectId: 'proj_a' }).confirmed, false);
+  /** 未绑定但带着 episodeId 的任务：作品候选失效，项目候选照常准入。 */
+  const unbound = learning.admissionOf(bound, {
+    projectId: 'proj_a',
+    anchor: { episodeId: 'e1', status: 'unbound', projectId: 'proj_a' },
+  });
+  assert.equal(unbound.ok, false);
+  assert.equal(unbound.reason, '作品绑定已经失效');
+  assert.equal(learning.admissionOf({ ...longTerm }, {
+    projectId: 'proj_a',
+    anchor: { episodeId: 'e9', status: 'unbound', projectId: 'proj_a' },
+  }).ok, true);
+  assert.equal(learning.admissionOf({ ...bound, confirmed: true }, {
+    projectId: 'proj_a',
+    anchor: { episodeId: 'e1', status: 'active', projectId: 'proj_a' },
+  }).requiresUserConfirmation, false);
+  assert.equal(learning.admissionOf(bound, { projectId: 'proj_a', anchor: { episodeId: 'e1', status: 'active' } }, 'commit').ok, false);
+  assert.equal(learning.admissionOf(null).ok, false);
+  assert.equal(learning.admissionOf(bound, { projectId: 'proj_b', anchor: { episodeId: 'e1', status: 'active' } }).ok, false);
+});
+
+test('L09 项目滚动额度与单次去重分离，开关不重置已用额度', () => {
+  let ledger = {};
+  const base = Date.parse('2026-01-01T00:00:00.000Z');
+  /** 同一期最多两次：去重按 episode 行记，滚动 recent 清空也不放宽。 */
+  ledger = learning.recordAttempt(ledger, { episodeId: 'e1', now: base });
+  assert.equal(learning.quota(ledger, { episodeId: 'e1', now: base }).ok, true);
+  ledger = learning.recordAttempt(ledger, { episodeId: 'e1', now: base + 1000 });
+  const episodeLimit = learning.quota(ledger, { episodeId: 'e1', now: base + 2000 });
+  assert.equal(episodeLimit.reason, 'episode_limit');
+  assert.equal(episodeLimit.episodeCount, learning.LIMITS.attemptsPerEpisode);
+  /** 模拟实验关开：state.applyEvolution 会清空 recent，attempts 保留。 */
+  const toggled = { ...learning.recordAttempt(ledger, { episodeId: 'e2', now: base + 3000 }), recent: [] };
+  assert.equal(learning.quota(toggled, { episodeId: 'e1', now: base + 4000 }).reason, 'episode_limit');
+  assert.equal(learning.quota(toggled, { episodeId: 'e2', now: base + 4000 }).episodeCount, 1);
+  /** 跨作品项目上限按窗口内总次数算，不依赖 recent。 */
+  let project = {};
+  for (const episodeId of ['p1', 'p1', 'p2', 'p2', 'p3', 'p3']) {
+    project = learning.recordAttempt(project, { episodeId, now: base });
+  }
+  project = { ...project, recent: [] };
+  const window = learning.attemptWindowOf(project, { now: base + 1000 });
+  assert.equal(window.projectCount, learning.LIMITS.attemptsPerProject);
+  assert.equal(learning.quota(project, { episodeId: 'p4', now: base + 1000 }).reason, 'project_limit');
+  /** 只按窗口自然衰减，不因开关或去重重置。 */
+  const later = base + learning.LIMITS.windowMs + 1;
+  assert.equal(learning.quota(project, { episodeId: 'p4', now: later }).ok, true);
+  assert.equal(learning.attemptWindowOf(project, { now: later }).projectCount, 0);
+  /** 项目层候选按 project:<key> 记账：不能被“每期两次”终身卡死，只受滚动项目额度约束。 */
+  let pseudo = {};
+  for (let index = 0; index < 3; index += 1) pseudo = learning.recordAttempt(pseudo, { episodeId: 'project:proj_a', now: base + index });
+  const pseudoQuota = learning.quota(pseudo, { episodeId: 'project:proj_a', now: base + 10 });
+  assert.equal(pseudoQuota.ok, true, JSON.stringify(pseudoQuota));
+  assert.equal(pseudoQuota.episodeCount, 0);
+  assert.equal(learning.quota(pseudo, { episodeId: '', now: base + 10 }).ok, true);
+  /** 两条不同作品各自占一次额度，单条去重不合并跨期调用。 */
+  const distinct = learning.recordAttempt(learning.recordAttempt({}, { episodeId: 'q1', now: base }), { episodeId: 'q2', now: base });
+  assert.equal(learning.quota(distinct, { episodeId: 'q3', now: base }).projectCount, 2);
+});
+
+test('L10 整理器规则先稳定排序再取 8', () => {
+  const rules = [];
+  for (let index = 0; index < 9; index += 1) {
+    rules.push({
+      id: `mem_${index}`,
+      status: 'active',
+      learning: { state: 'pending', updatedAt: new Date(Date.UTC(2026, 0, 1, 0, index)).toISOString() },
+      updated: new Date(Date.UTC(2026, 0, 1, 0, index)).toISOString(),
+    });
+  }
+  /** 真正可用的旧经验排在输入最后：先截断就会丢掉它。 */
+  rules.push({
+    id: 'mem_star',
+    status: 'active',
+    learning: { state: 'active', lastUsedAt: '2025-12-31T00:00:00.000Z', updatedAt: '2025-01-01T00:00:00.000Z' },
+    updated: '2025-01-01T00:00:00.000Z',
+  });
+  assert.equal(rules.slice(0, 8).some((row) => row.id === 'mem_star'), false);
+  const ordered = learning.orderOrganizerRules(rules);
+  assert.equal(ordered.length, learning.LIMITS.organizerRules);
+  assert.equal(ordered[0].id, 'mem_star');
+  assert.equal(ordered.some((row) => row.id === 'mem_star'), true);
+  /** 同样输入换个顺序结果一样；同状态按最近使用、再按时间、最后按 id。 */
+  const shuffled = [...rules].reverse();
+  assert.deepEqual(learning.orderOrganizerRules(shuffled).map((row) => row.id), ordered.map((row) => row.id));
+  const sameState = [
+    { id: 'b', learning: { state: 'active', updatedAt: '2025-01-01T00:00:00.000Z' } },
+    { id: 'a', learning: { state: 'active', lastUsedAt: '2026-01-01T00:00:00.000Z', updatedAt: '2025-01-01T00:00:00.000Z' } },
+    { id: 'c', learning: { state: 'active', updatedAt: '2025-01-01T00:00:00.000Z' } },
+  ];
+  assert.deepEqual(learning.orderOrganizerRules(sameState, { limit: 2 }).map((row) => row.id), ['a', 'b']);
+  assert.equal(learning.orderOrganizerRules([], { limit: 3 }).length, 0);
+});
+
 console.log(`learning.test.mjs: ${passed} passed`);

package/test/palace.test.mjs

@@ -0,0 +1,102 @@
+import assert from 'node:assert/strict';
+
+let seen = null;
+const makeNode = (type, props, ...children) => ({ type, props: props || {}, children: children.flat(Infinity) });
+const fakeReact = {
+  createElement: makeNode,
+  useRef: (value) => ({ current: value }),
+  useState: (value) => [value, () => {}],
+  useEffect: () => {},
+  useMemo: (fn) => fn(),
+};
+globalThis.window = {
+  __ModuleLoader__: {
+    load: (definition) => {
+      definition.factory((name) => (name === 'react' ? fakeReact : null));
+    },
+  },
+};
+globalThis.__LITE_MEMORY_TEST__ = (helpers) => { seen = helpers; };
+await import('../client.js');
+assert.ok(seen, 'client test seam missing');
+
+const {
+  MemoryPalace, MemoryPanel, viewModeOf, palaceRoomsOf, palaceRoomPageOf,
+  palacePageWindow, palaceToggleOf, palaceMotionOf, palaceRoomIdOf,
+} = seen;
+
+const record = (id, kind, title = id) => ({ id, kind, title });
+
+// 房间按固定顺序归类，未知类型落到「其他记录」，不丢记录。
+const rooms = palaceRoomsOf([
+  record('mem_1', 'note'),
+  record('mem_2', 'pointer'),
+  record('mem_3', 'procedure'),
+  record('mem_4', 'preference'),
+  record('mem_5', 'convention'),
+  record('mem_6', 'pitfall'),
+  record('mem_7', 'credential_hint'),
+  record('mem_8', 'unknown_kind'),
+]);
+assert.deepEqual(rooms.map((room) => room.name), ['习惯与规范', '方法与经验', '资料与入口', '其他记录']);
+assert.deepEqual(rooms.map((room) => room.total), [2, 2, 2, 2]);
+assert.equal(palaceRoomIdOf('unknown_kind'), 'notes');
+assert.deepEqual(palaceRoomsOf([record('mem_9', 'note')]).map((room) => room.total), [0, 0, 0, 1], '空房间保留位置');
+
+// 一页固定 24 个槽位，页码夹在有效范围内。
+const many = Array.from({ length: 25 }, (_, index) => record(`mem_${index}`, 'preference', `P${index}`));
+const manyRooms = palaceRoomsOf(many);
+assert.equal(manyRooms.length, 4);
+assert.equal(manyRooms[0].total, 25);
+assert.equal(manyRooms[0].pages, 2);
+const first = palaceRoomPageOf(many, 'habits', 1);
+assert.equal(first.items.length, 24);
+assert.equal(first.page, 1);
+const second = palaceRoomPageOf(many, 'habits', 2);
+assert.equal(second.items.length, 1);
+assert.equal(second.page, 2);
+assert.equal(palaceRoomPageOf(many, 'habits', 99).page, 2);
+assert.equal(palaceRoomPageOf(many, 'habits', 0).page, 1);
+assert.deepEqual(palacePageWindow(1, 3), [1, 2, 3]);
+assert.deepEqual(palacePageWindow(5, 12), [2, 3, 4, 5, 6, 7, 8]);
+assert.equal(palacePageWindow(12, 12).includes(12), true);
+
+// 同一时刻只展开一间：再点已展开的房间会收起。
+assert.equal(palaceToggleOf('', 'methods'), 'methods');
+assert.equal(palaceToggleOf('methods', 'methods'), '');
+assert.equal(palaceToggleOf('methods', 'habits'), 'habits');
+
+// 视图开关关闭时回列表，关闭的宫殿不进入组件树。
+assert.equal(viewModeOf({ graph: true, palace: false }, 'palace'), 'list');
+assert.equal(viewModeOf({ graph: false, palace: true }, 'palace'), 'palace');
+assert.equal(viewModeOf({ graph: false, palace: false }, 'graph'), 'list');
+
+// 减少动态时无动画，普通情况 180ms。
+assert.equal(palaceMotionOf(true).duration, 0);
+assert.equal(palaceMotionOf(false).duration, 180);
+
+// 点击展品只把 record.id 交给现有详情入口，不另造详情。
+let picked = '';
+const tree = MemoryPalace({
+  records: [record('mem_a', 'preference', 'A')],
+  selectedId: '', onPick: (id) => { picked = id; }, emptyText: '这个项目还没有记忆',
+});
+const walk = (node, out = [], expand = false) => {
+  if (!node || typeof node !== 'object') return out;
+  if (expand && typeof node.type === 'function') return walk(node.type(node.props), out, true);
+  out.push(node);
+  for (const child of node.children || []) walk(child, out, expand);
+  return out;
+};
+const exhibit = walk(tree, [], true).find((node) => node.type === 'button' && node.props.title === 'A');
+assert.ok(exhibit, '展品应是原生按钮');
+exhibit.props.onClick();
+assert.equal(picked, 'mem_a');
+
+// 首帧列表视图不挂载宫殿；空数据时给下一步提示。
+const firstPaint = MemoryPanel({ sessionId: 'demo', onClose: () => {} });
+assert.equal(walk(firstPaint).some((node) => node.type === MemoryPalace), false);
+const emptyTree = MemoryPalace({ records: [], selectedId: '', onPick: () => {}, emptyText: '这个项目还没有记忆' });
+assert.equal(walk(emptyTree).some((node) => node.children.includes('这个项目还没有记忆')), true);
+
+console.log('palace.test.mjs: all passed');