dsh-lite-memory 0.16.2 → 0.17.0

package/test/store.test.mjs

@@ -10,7 +10,7 @@ const state = await import('../state.js');
 const { upsert, search, readEntry, forget, undoChange, acceptCandidate, rejectCandidate,
   suggestionGate, noteSuggestion, findSuggestion, renderIndex, normalizeDraft, loadIndex,
   scopeOf, globalScope, LIMITS, recordCitations, listCitations, readCitationBody,
-  evolutionStatus, setEvolution } = store;
+  evolutionStatus, setEvolution, saveIndex } = store;
 
 let passed = 0;
 const test = (name, fn) => {
@@ -153,14 +153,18 @@ test('oversized body is rejected, old data untouched', () => {
   assert.equal(loadIndex(scope).entries[0].revision, 1);
 });
 
-test('over-long title is an error; over-long summary is truncated but the full text is saved', () => {
+test('over-long title is an error; over-long summary keeps its full text outside the body', () => {
   const scope = fresh('length');
   assert.throws(() => upsert(scope, { title: 't'.repeat(LIMITS.titleChars + 1), summary: '写得短一点' }), /标题超过/);
   const long = '长'.repeat(LIMITS.summaryChars + 1);
   const saved = upsert(scope, { title: '长摘要', summary: long });
   assert.equal(saved.record.summary.length, LIMITS.summaryChars);
-  assert.equal(readEntry(scope, saved.record.id).body, long);
-  assert.equal(saved.draft.fullTextInBody, true);
+  /** 完整原句进维护区，正文保持空：不再往正文里补「摘要原文」尾巴。 */
+  assert.equal(readEntry(scope, saved.record.id).body, '');
+  assert.equal(saved.record.summaryFull, long);
+  assert.equal(readEntry(scope, saved.record.id).maintenance.summaryFull, long);
+  assert.equal(saved.draft.fullTextSaved, true);
+  assert.equal(saved.draft.fullTextInBody, false);
   assert.equal(saved.draft.summaryShortened, true);
 });
 
@@ -269,7 +273,8 @@ test('forget archives both body and record; undo restores the previous version',
   assert.equal(countOf(scope), 0);
   const archived = loadIndex(scope).archived.find((item) => item.id === first.record.id);
   assert.equal(archived.status, 'archived');
-  assert.equal(archived.body, '第一版正文');
+  assert.equal(archived.body, '', '列表只拿归档元数据，不读冷存正文');
+  assert.equal(readEntry(scope, first.record.id).body, '第一版正文', '真要读这一条时才从冷存取');
   const againArchive = forget(scope, first.record.id, { mode: 'archive' });
   assert.equal(againArchive.mode, 'archive');
   assert.equal(againArchive.already, true);
@@ -860,29 +865,463 @@ test('R24 省略正文的更新不覆盖已有正文（按 id 与同名都成立
   assert.equal(bodyOf(scope, id), '旧正文：先看连接数。', '同名更新省略正文时保留原正文');
 });
 
-test('R25 长摘要改动即使只差第 61 个字符也算改过，全文仍保留', () => {
+test('R25 长摘要改动即使只差第 61 个字符也算改过，完整原句另存', () => {
   const scope = fresh('long-summary-change');
   const head = '摘要主体'.repeat(15);
   const first = upsert(scope, { title: '长摘要规则', summary: `${head}甲` });
   const id = first.record.id;
   assert.equal(first.record.summary.length, LIMITS.summaryChars);
-  assert.match(bodyOf(scope, id), /甲$/);
+  assert.equal(bodyOf(scope, id), '', '正文不塞摘要原文');
+  assert.equal(first.record.summaryFull, `${head}甲`);
   const again = upsert(scope, { id, title: '长摘要规则', summary: `${head}乙` });
   assert.equal(again.noop, false, '第 61 个字符变化不能当作没改');
-  const body = bodyOf(scope, id);
-  assert.match(body, /甲/);
-  assert.match(body, /乙/, '新的完整摘要也落盘');
+  assert.equal(bodyOf(scope, id), '');
+  assert.equal(again.record.summaryFull, `${head}乙`, '新的完整摘要也落盘');
+  assert.equal(again.record.maintenance.summaryFull, `${head}乙`);
   assert.equal(again.record.summary.length, LIMITS.summaryChars);
 });
 
-test('R26 显式长正文加短摘要时补上摘要原文，不把两者混成一条', () => {
+test('R26 显式长正文加短摘要时完整原句另存，不混进正文', () => {
   const scope = fresh('body-plus-summary');
   const long = '现场记录'.repeat(20);
   const saved = upsert(scope, { title: '带正文的长摘要', summary: long, body: '显式正文：先复现再改。' });
-  const body = bodyOf(scope, saved.record.id);
-  assert.match(body, /^显式正文：先复现再改。/);
-  assert.match(body, /摘要原文：/);
-  assert.match(body, /现场记录/);
+  const record = readEntry(scope, saved.record.id);
+  assert.equal(record.body, '显式正文：先复现再改。');
+  assert.doesNotMatch(record.body, /摘要原文：/);
+  assert.equal(record.summaryFull, long);
+  assert.equal(record.maintenance.summaryFull, long);
+  assert.equal(saved.draft.fullTextSaved, true);
+  assert.equal(saved.draft.fullTextInBody, false);
+});
+
+// ── 长摘要、用户正文里的「摘要原文：」、凭据、冷存删除 ─────────────────
+test('用户正文里自带「摘要原文：」时原样保留，保存与再次更新都不改写', () => {
+  const scope = fresh('user-tail-text');
+  const body = '用户原话：\n摘要原文：这里本来就是正文的一部分，别动它。';
+  const saved = upsert(scope, { title: '用户写的正文', summary: '用户正文原样保留', body });
+  const id = saved.record.id;
+  assert.equal(bodyOf(scope, id), body);
+  upsert(scope, { id, title: '用户写的正文', summary: '再更新一次也不动正文', body });
+  assert.equal(bodyOf(scope, id), body, '第二次更新也不能剥离用户正文');
+  assert.equal(readEntry(scope, id).maintenance.legacySummaryTail, true, '旧标记只做待整理提示');
+});
+
+test('长摘要改短后清掉旧的完整原句，不留托管尾巴', () => {
+  const scope = fresh('summary-cleared');
+  const long = '完整摘要'.repeat(20);
+  const saved = upsert(scope, { title: '先长后短', summary: long });
+  const id = saved.record.id;
+  assert.equal(readEntry(scope, id).summaryFull, long);
+  upsert(scope, { id, title: '先长后短', summary: '改成一句短的' });
+  const record = readEntry(scope, id);
+  assert.equal(record.summaryFull, '');
+  assert.equal(record.maintenance.summaryFull, undefined);
+  assert.equal(record.body, '');
+  assert.equal(stateOf(scope).entries[0].maintenance.summaryFull, undefined, '热状态里也不留旧原文');
+});
+
+test('冷存共享原文片段时只删目标条目，另一条的正文与历史完整', () => {
+  const scope = fresh('cold-shared');
+  const shared = '这段原文两条都用到';
+  const a = upsert(scope, { title: '共享片段 A', summary: '第一条', body: `${shared}，A 的细节` });
+  const b = upsert(scope, { title: '共享片段 B', summary: '第二条', body: `${shared}，B 的细节`, resolution: 'distinct' });
+  upsert(scope, { id: b.record.id, title: '共享片段 B', summary: '第二条改过', body: `${shared}，B 的第二版` });
+  forget(scope, a.record.id, { mode: 'archive' });
+  forget(scope, b.record.id, { mode: 'archive' });
+  const coldA = path.join(scope.dir, 'cold', `${a.record.id}.json`);
+  const coldB = path.join(scope.dir, 'cold', `${b.record.id}.json`);
+  assert.equal(fs.existsSync(coldA), true);
+  assert.equal(fs.existsSync(coldB), true);
+  forget(scope, a.record.id, { mode: 'purge' });
+  assert.equal(fs.existsSync(coldA), false, 'A 的冷存按 id 删除');
+  assert.equal(fs.existsSync(coldB), true, 'B 的冷存一个字都不能动');
+  const left = readEntry(scope, b.record.id);
+  assert.equal(left.body, `${shared}，B 的第二版`);
+  assert.ok(left.versions.length >= 1, 'B 的历史版本还在');
+  assert.match(JSON.stringify(fs.readFileSync(coldB, 'utf8')), /B 的第一版|B 的细节|B 的第二版/);
+  assert.equal(fs.existsSync(path.join(scope.dir, 'cold')), true);
+});
+
+test('冷存缺失、损坏或身份不符时报明确错误，不拿空正文顶上', () => {
+  const scope = fresh('cold-broken');
+  const saved = upsert(scope, { title: '冷存出错', summary: '读回要报错', body: '冷存正文：读回要报错' });
+  const id = saved.record.id;
+  forget(scope, id, { mode: 'archive' });
+  const file = path.join(scope.dir, 'cold', `${id}.json`);
+  const good = fs.readFileSync(file, 'utf8');
+  fs.writeFileSync(file, '{ 不是 json');
+  assert.doesNotThrow(() => loadIndex(scope), '列表不读归档正文，冷存坏了也不能整层失败');
+  assert.throws(() => readEntry(scope, id), /冷存|cold_corrupt/);
+  fs.writeFileSync(file, JSON.stringify({ id: 'other', scope: scope.key, revision: 1, body: '别人的正文' }));
+  assert.throws(() => readEntry(scope, id), /冷存|cold_corrupt/);
+  fs.rmSync(file);
+  assert.throws(() => readEntry(scope, id), /冷存|cold_missing/);
+  fs.writeFileSync(file, good);
+  assert.equal(readEntry(scope, id).body, '冷存正文：读回要报错');
+});
+
+test('归档正文懒加载：列表与 snapshot 不读冷存，只有读到该条正文才报 cold_missing', () => {
+  const scope = fresh('cold-lazy');
+  const saved = upsert(scope, { title: '归档懒读', summary: '列表不读正文', body: '懒加载正文：只有读这一条才取' });
+  const id = saved.record.id;
+  forget(scope, id, { mode: 'archive' });
+  const file = path.join(scope.dir, 'cold', `${id}.json`);
+  assert.equal(fs.existsSync(file), true);
+  fs.rmSync(file);
+  const index = loadIndex(scope);
+  const archived = index.archived.find((row) => row.id === id);
+  assert.ok(archived, '归档元数据照常加载');
+  assert.equal(archived.body, '');
+  assert.equal(archived.coldBody, '');
+  assert.doesNotThrow(() => store.learningSnapshot(scope));
+  assert.equal(search(scope, '归档懒读').length, 0, '列表/搜索只认真在用（active）的记录');
+  assert.throws(() => readEntry(scope, id), /冷存|cold_missing/, '真要读这一条正文时缺冷存就报明确错误');
+});
+
+test('被截掉的摘尾巴里藏凭据也要拒绝', () => {
+  const scope = fresh('summary-tail-secret');
+  const mask = '这条摘要的前半段可以短一点'.repeat(5);
+  const secret = ' token = sk-abcdefghijklmnopqrst';
+  assert.throws(() => upsert(scope, {
+    title: '凭据藏尾巴', summary: `${mask}${secret}`, body: '显式正文',
+  }), /凭据/);
+  assert.equal(fs.existsSync(path.join(scope.dir, 'state.json')), false);
+});
+
+test('归属路由：本机痕迹的「通用流程」留在项目层，干净流程带依据才进全局', () => {
+  const project = { confirmed: true };
+  const bound = store.routeScope({
+    title: '部署脚本', summary: '本机部署脚本的位置', body: 'bash /tmp/deploy.sh，再看 127.0.0.1:8080',
+    memoryClass: 'portable_procedure', scope: 'global',
+  }, { project });
+  assert.equal(bound.chosenScope, 'project');
+  assert.equal(bound.reasonCode, 'machine_bound_scope');
+
+  const boundNoScope = store.routeScope({
+    title: '本机路径', summary: '部署脚本在 /tmp 下', body: 'bash /tmp/deploy.sh',
+    memoryClass: 'portable_procedure',
+  }, { project });
+  assert.equal(boundNoScope.chosenScope, 'project');
+  assert.equal(boundNoScope.reasonCode, 'machine_bound_procedure');
+
+  const noEvidence = store.routeScope({
+    title: '提交前跑测试', summary: '提交前跑测试', body: 'pnpm test',
+    memoryClass: 'portable_procedure',
+  }, { project });
+  assert.equal(noEvidence.chosenScope, 'project');
+  assert.equal(noEvidence.reasonCode, 'unbound_evidence');
+
+  const withEvidence = store.routeScope({
+    title: '提交前跑测试', summary: '提交前跑测试', body: 'pnpm test',
+    memoryClass: 'portable_procedure', evidenceRef: '团队 wiki 的提交流程页',
+  }, { project });
+  assert.equal(withEvidence.chosenScope, 'global');
+  assert.equal(withEvidence.reasonCode, 'class_portable_procedure');
+
+  const evidencePath = store.routeScope({
+    title: '提交前跑测试', summary: '提交前跑测试', body: 'pnpm test',
+    memoryClass: 'portable_procedure', evidenceRef: '/tmp/notes/deploy.md',
+  }, { project });
+  assert.equal(evidencePath.chosenScope, 'project', '依据本身是本机文件不算普适证据');
+  assert.equal(evidencePath.reasonCode, 'machine_bound_procedure');
+
+  const unconfirmed = store.routeScope({
+    title: '部署脚本', summary: '本机部署脚本', body: 'bash /tmp/deploy.sh',
+    memoryClass: 'portable_procedure', scope: 'global',
+  }, { project: { confirmed: false } });
+  assert.equal(unconfirmed.needsScope, true);
+  assert.equal(unconfirmed.reasonCode, 'needs_environment');
+  assert.deepEqual(unconfirmed.requiredConditions.map((row) => row.key), ['machine', 'runtime']);
+
+  const humanGlobal = store.routeScope({
+    title: '部署脚本', summary: '本机部署脚本', body: 'bash /tmp/deploy.sh',
+    memoryClass: 'portable_procedure', scope: 'global',
+  }, { project, humanScope: true });
+  assert.equal(humanGlobal.chosenScope, 'global');
+  assert.equal(humanGlobal.reasonCode, 'explicit');
+
+  const modelGlobalFact = store.routeScope({
+    title: '发布分支', summary: '本仓库发布分支是 main', body: 'main',
+    memoryClass: 'project_fact', scope: 'global',
+  }, { project });
+  assert.equal(modelGlobalFact.chosenScope, 'project', '模型自填 global 不能把项目事实送进全局层');
+  assert.equal(modelGlobalFact.reasonCode, 'model_global_project_fact');
+
+  const modelGlobalProcedure = store.routeScope({
+    title: '提交前跑测试', summary: '提交前跑测试', body: 'pnpm test',
+    memoryClass: 'portable_procedure', scope: 'global',
+  }, { project });
+  assert.equal(modelGlobalProcedure.chosenScope, 'project', '模型自填 global 少了依据也不能进全局层');
+  assert.equal(modelGlobalProcedure.reasonCode, 'unbound_evidence');
+});
+
+test('几百条归档的正文不进热状态，下一次保存照样能过', () => {
+  const scope = fresh('cold-archives');
+  fs.mkdirSync(scope.dir, { recursive: true });
+  const at = new Date(Date.now() - 86_400_000).toISOString();
+  const row = (id, status, title, body) => ({
+    id,
+    revision: 1,
+    status,
+    origin: 'user_explicit',
+    createdAt: at,
+    updatedAt: at,
+    current: {
+      title, summary: title, body, kind: 'note', when: '', keywords: [], topicKey: '',
+      triggers: [], applicability: 'all_in_scope', conditions: [], selection: null, links: [], aliases: [],
+    },
+    maintenance: { reviewState: 'current', sourceRefs: [], retiredNames: [], versions: [], checks: [], hits: 0, merges: 0, lastUsed: at },
+  });
+  const build = (chars) => {
+    const big = state.emptyState(scope);
+    big.entries.push(row('mem_cold00000001', 'active', '现役条目', '现役正文'));
+    const body = '归档正文示例'.repeat(1).padEnd(1) + '归'.repeat(chars);
+    for (let i = 0; i < 480; i += 1) {
+      big.entries.push(row(`mem_cold${String(i + 2).padStart(8, '0')}`, 'archived', `旧条目 ${i}`, body));
+    }
+    return state.encodeState(big);
+  };
+  let chars = 1400;
+  let encoded = build(chars);
+  for (let attempt = 0; attempt < 30 && Buffer.byteLength(encoded) > LIMITS.stateBytes - 1200; attempt += 1) {
+    const over = Buffer.byteLength(encoded) - (LIMITS.stateBytes - 1200);
+    chars -= Math.max(1, Math.ceil(over / (480 * 3)));
+    encoded = build(chars);
+  }
+  const seeded = Buffer.byteLength(encoded);
+  assert.ok(seeded <= LIMITS.stateBytes, '造出的热状态本身还得读得动');
+  assert.ok(seeded > LIMITS.stateBytes - 3200, '离上限只差一条新记忆');
+  fs.writeFileSync(path.join(scope.dir, 'state.json'), encoded);
+
+  const saved = upsert(scope, { title: '新的一条', summary: '归档再多也要能写', body: '新正文'.repeat(400) });
+  assert.equal(saved.record.title, '新的一条');
+  assert.ok(Buffer.byteLength(rawState(scope)) < LIMITS.stateBytes, '热状态回到上限内');
+  assert.equal(fs.existsSync(path.join(scope.dir, 'cold')), true);
+  assert.equal(fs.existsSync(path.join(scope.dir, 'archive')), false);
+  const archivedId = 'mem_cold00000002';
+  assert.match(readEntry(scope, archivedId).body, /归档正文示例/, '归档正文还能读到');
+  assert.match(search(scope, '新的一条')[0].title, /新的一条/);
+});
+
+test('lastUsed 只在真读过且够旧时回写，刚存下的条目不动', () => {
+  const scope = fresh('last-used-touch');
+  const created = upsert(scope, { title: '会被读的条目', summary: '读一次要记下用过', body: '正文' });
+  const id = created.record.id;
+  const freshUsed = loadIndex(scope).entries.find((entry) => entry.id === id).lastUsed;
+  readEntry(scope, id);
+  assert.equal(loadIndex(scope).entries.find((entry) => entry.id === id).lastUsed, freshUsed, '十分钟内不写盘');
+  search(scope, '会被读的条目');
+  assert.equal(loadIndex(scope).entries.find((entry) => entry.id === id).lastUsed, freshUsed);
+
+  const stale = new Date(Date.now() - 11 * 60 * 1000).toISOString();
+  const index = loadIndex(scope);
+  index.entries.find((entry) => entry.id === id).lastUsed = stale;
+  store.saveIndex(scope, index);
+  assert.equal(stateOf(scope).entries.find((entry) => entry.id === id).maintenance.lastUsed, stale);
+  readEntry(scope, id);
+  const touched = loadIndex(scope).entries.find((entry) => entry.id === id).lastUsed;
+  assert.notEqual(touched, stale);
+  assert.ok(Date.now() - Date.parse(touched) < 60_000, '过旧时读一次就回写');
+
+  const other = upsert(scope, { title: '葡萄柚检索目标', summary: '葡萄柚专用的检索记录', body: '葡萄柚正文' });
+  assert.ok(other.record, '第二条要真的新建出来');
+  const staleSearch = new Date(Date.now() - 11 * 60 * 1000).toISOString();
+  const again = loadIndex(scope);
+  again.entries.find((entry) => entry.id === other.record.id).lastUsed = staleSearch;
+  store.saveIndex(scope, again);
+  search(scope, '葡萄柚检索目标');
+  assert.notEqual(loadIndex(scope).entries.find((entry) => entry.id === other.record.id).lastUsed, staleSearch);
+});
+
+test('项目层未绑作品的候选也能开始整理并提交成规则', () => {
+  const scope = fresh('learning-unbound');
+  const on = setEvolution(scope, true, { operationId: 'evo-unbound-on' });
+  assert.equal(on.ok, true);
+  const started = store.beginLearningAttempt(scope, { episodeId: '', operationId: 'unbound-start' });
+  assert.equal(started.ok, true, started.reason);
+  assert.equal(started.episodeId, '', '不编造作品 id');
+  const change = {
+    target: 'new', feedbackType: 'spec_change', topicKey: '口播开头',
+    currentText: '开头三句内给结论。', applicability: 'conditional',
+    conditions: [{ key: 'seriesId', value: '口播' }], evidence: ['u0'], persistence: 'project_candidate',
+  };
+  const committed = store.commitLearning(scope, {
+    operationId: 'unbound-commit', epoch: started.epoch, episodeId: '', projectId: scope.key,
+    sessionId: 's-unbound', messageIds: ['m1'], changes: [change], preparedTargets: [],
+  });
+  assert.equal(committed.ok, true, committed.reason);
+  const rules = stateOf(scope).entries.filter((entry) => entry.origin === 'project_evolution');
+  assert.equal(rules.length, 1);
+  assert.match(rules[0].current.title, /开头|口播/);
+
+  const foreign = store.commitLearning(scope, {
+    operationId: 'unbound-foreign', epoch: started.epoch, episodeId: '', projectId: 'other-project',
+    sessionId: 's-unbound', messageIds: ['m1'], changes: [change], preparedTargets: [],
+  });
+  assert.equal(foreign.ok, false);
+  assert.match(foreign.reason, /缺少作品标识/);
+});
+
+test('整理回执的 evidence 带上用户原句，优先本次改动其次整批', () => {
+  const changeFor = (extra = {}) => ({
+    target: 'new', feedbackType: 'spec_change', topicKey: '口播开头',
+    currentText: '开头三句内给结论。', applicability: 'conditional',
+    conditions: [{ key: 'seriesId', value: '口播' }], evidence: ['u0'], persistence: 'project_candidate',
+    ...extra,
+  });
+  const commitOnce = (scope, batchExcerpt, changeExcerpt) => {
+    assert.equal(setEvolution(scope, true, { operationId: `evo-evidence-${scope.key}` }).ok, true);
+    const started = store.beginLearningAttempt(scope, { episodeId: '', operationId: `start-evidence-${scope.key}` });
+    assert.equal(started.ok, true, started.reason);
+    const committed = store.commitLearning(scope, {
+      operationId: `commit-evidence-${scope.key}`, epoch: started.epoch, episodeId: '', projectId: scope.key,
+      sessionId: 's-evidence', messageIds: ['m1', 'm2'],
+      sourceExcerpt: batchExcerpt,
+      changes: [changeFor(changeExcerpt ? { sourceExcerpt: changeExcerpt } : {})], preparedTargets: [],
+    });
+    assert.equal(committed.ok, true, committed.reason);
+    return loadIndex(scope).entries.find((entry) => entry.origin === 'project_evolution');
+  };
+  const fromBatch = commitOnce(fresh('evidence-batch'), '用户原话：开头别绕，三句内给结论。');
+  assert.equal(fromBatch.learning.sourceExcerpt, '用户原话：开头别绕，三句内给结论。');
+  assert.deepEqual(fromBatch.learning.sourceRefs.at(-1).messageIds, ['m1', 'm2'], 'messageIds 仍是真实消息');
+  const fromChange = commitOnce(fresh('evidence-change'), '整批摘录不该优先', '用户原话：开头三句内给结论，别铺垫。');
+  assert.equal(fromChange.learning.sourceExcerpt, '用户原话：开头三句内给结论，别铺垫。', '本次改动摘录优先');
+});
+
+test('整理器规则顺序与开始整理时一致，按状态/最近使用排而不是插入顺序', () => {
+  const scope = fresh('organizer-order');
+  const on = setEvolution(scope, true, { operationId: 'order-evo-on' });
+  assert.equal(on.ok, true, on.reason);
+  const started = store.beginLearningAttempt(scope, { episodeId: '', operationId: 'order-start' });
+  assert.equal(started.ok, true, started.reason);
+  const changes = ['先写的旧规则', '后写的新规则'].map((topic) => ({
+    target: 'new', feedbackType: 'spec_change', topicKey: topic,
+    currentText: `${topic}：按规则走。`, applicability: 'all_in_scope',
+    evidence: ['u0'], persistence: 'project_candidate',
+  }));
+  const committed = store.commitLearning(scope, {
+    operationId: 'order-commit', epoch: started.epoch, projectId: scope.key,
+    sessionId: 's-order', messageIds: ['m1'], changes, preparedTargets: [],
+  });
+  assert.equal(committed.ok, true, committed.reason);
+  const organizer = store.learningRulesForOrganizer(scope).map((row) => row.id);
+  assert.equal(organizer.length, 2);
+  assert.deepEqual(store.learningRulesForOrganizer(scope).map((row) => row.id), organizer, '顺序确定，重复调用不变');
+  const again = store.beginLearningAttempt(scope, { episodeId: '', operationId: 'order-start-2' });
+  assert.equal(again.ok, true, again.reason);
+  assert.deepEqual(again.rules.map((row) => row.id), organizer, '两处必须同一个顺序');
+});
+
+/** 冷存是归档正文唯一的家：写入必须和 state.json 一样 fsync 文件 + 目录，失败要整次保存失败。 */
+const traceDurability = () => {
+  const opened = new Map();
+  const synced = [];
+  const realOpen = fs.openSync;
+  const realFsync = fs.fsyncSync;
+  fs.openSync = (file, flags, ...rest) => {
+    const fd = realOpen.call(fs, file, flags, ...rest);
+    opened.set(fd, String(file));
+    return fd;
+  };
+  fs.fsyncSync = (fd) => {
+    synced.push(opened.get(fd) || '');
+    return realFsync.call(fs, fd);
+  };
+  return {
+    opened,
+    synced,
+    restore() {
+      fs.openSync = realOpen;
+      fs.fsyncSync = realFsync;
+    },
+  };
+};
+
+test('归档正文写冷存时 fsync 文件和目录（与 state.json 同一落盘序列）', () => {
+  const scope = fresh('cold-fsync-trace');
+  const created = upsert(scope, { title: '落盘冷存', summary: '冷存落盘序列', kind: 'note' }, {});
+  const trace = traceDurability();
+  try {
+    const result = forget(scope, created.record.id, { mode: 'archive' });
+    assert.equal(result.mode, 'archive');
+  } finally {
+    trace.restore();
+  }
+  const coldDir = path.join(scope.dir, 'cold');
+  assert.ok(trace.synced.some((file) => file === coldDir), `冷存目录要 fsync：${JSON.stringify(trace.synced)}`);
+  assert.ok(trace.synced.some((file) => file.startsWith(path.join(coldDir, '.')) && file.endsWith('.tmp')),
+    `冷存临时文件要先 fsync 再 rename：${JSON.stringify(trace.synced)}`);
+  const file = path.join(coldDir, `${created.record.id}.json`);
+  assert.equal(fs.existsSync(file), true);
+  assert.equal(fs.existsSync(`${file}.tmp`), false);
+});
+
+test('冷存 fsync 失败时保存失败、不发布状态、不留半个冷存文件', () => {
+  const scope = fresh('cold-fsync-fail');
+  const body = '归档正文必须能读回来';
+  const created = upsert(scope, { title: '写不进去的冷存', summary: '冷存 fsync 失败', body, kind: 'note' }, {});
+  const trace = traceDurability();
+  const coldDir = path.join(scope.dir, 'cold');
+  try {
+    const opened = trace.opened;
+    const real = fs.fsyncSync;
+    fs.fsyncSync = (fd) => {
+      const file = opened.get(fd) || '';
+      if (file.startsWith(path.join(coldDir, '.')) && file.endsWith('.tmp')) {
+        const error = new Error('injected fsync failure');
+        error.code = 'EIO';
+        throw error;
+      }
+      return real.call(fs, fd);
+    };
+    assert.throws(() => forget(scope, created.record.id, { mode: 'archive' }),
+      (error) => error.code === 'unavailable' && /归档正文没写进冷存/.test(error.message));
+  } finally {
+    trace.restore();
+  }
+  assert.equal(fs.existsSync(path.join(coldDir, `${created.record.id}.json`)), false, 'fsync 没成功就不能有权威冷存文件');
+  const tmpLeft = fs.existsSync(coldDir) ? fs.readdirSync(coldDir).filter((name) => name.endsWith('.tmp')) : [];
+  assert.deepEqual(tmpLeft, [], '失败的临时文件要清掉');
+  assert.equal(bodyOf(scope, created.record.id), body, '发布失败时热状态原样保留正文');
+  const retried = forget(scope, created.record.id, { mode: 'archive' });
+  assert.equal(retried.mode, 'archive');
+  const healed = readEntry(scope, created.record.id);
+  assert.equal(healed.status, 'archived');
+  assert.equal(healed.body, body);
+});
+
+
+test('一条冷存文件损坏不再拖死整层写入：退回热正文并重写好文件', () => {
+  const scope = fresh('cold-corrupt-heal');
+  const body = '归档正文还能从热状态找回来';
+  const created = upsert(scope, { title: '冷存坏了', summary: '损坏自愈', body, kind: 'note' }, {});
+  const coldFile = path.join(scope.dir, 'cold', `${created.record.id}.json`);
+  fs.mkdirSync(path.dirname(coldFile), { recursive: true });
+  fs.writeFileSync(coldFile, '{"broken":');
+  const index = loadIndex(scope);
+  /** 模拟预算腾位：正文还在热状态，索引里只留归档占位（没有 coldBody，必须去读冷存）。 */
+  index.archived = [{ id: created.record.id, title: '冷存坏了', status: 'archived' }];
+  index.entries = index.entries.filter((row) => row.id !== created.record.id);
+  saveIndex(scope, index);
+  const healed = readEntry(scope, created.record.id);
+  assert.equal(healed.status, 'archived');
+  assert.equal(healed.body, body, '自愈后正文要读得回来');
+  assert.equal(JSON.parse(fs.readFileSync(coldFile, 'utf8')).body, body, '坏文件要被重写成好文件');
+});
+
+test('冷存坏了且热状态也没有正文：仍然明确报 cold_corrupt，不冒充空正文', () => {
+  const scope = fresh('cold-corrupt-fail');
+  upsert(scope, { title: '占位', summary: '保持状态存在', body: '正常正文', kind: 'note' });
+  const orphan = 'mem_999999999999';
+  const coldFile = path.join(scope.dir, 'cold', `${orphan}.json`);
+  fs.mkdirSync(path.dirname(coldFile), { recursive: true });
+  fs.writeFileSync(coldFile, 'not json');
+  const index = loadIndex(scope);
+  index.archived = [{ id: orphan, title: '孤儿归档', status: 'archived' }];
+  assert.throws(() => saveIndex(scope, index), (error) => error.code === 'cold_corrupt');
+  assert.equal(fs.readFileSync(coldFile, 'utf8'), 'not json', '救不回来时不动那个坏文件');
+  assert.equal(index.entries.length, 1, '失败时不能悄悄丢掉别的条目');
 });
 
 console.log(`store.test.mjs: ${passed} passed`);

package/view.js

@@ -216,6 +216,48 @@ export function statusOf(record, context) {
   return 'not_applicable';
 }
 
+/**
+ * 所有读入口只走这一处：项目归属、实验开关、学习状态、试用到期、暂停/冲突、复核状态、适用性。
+ * auto 只放行完全匹配；search 允许条件未知（只给状态）；read 允许条件未知但要正文由调用方决定。
+ */
+/** 条件上下文与请求任务合并：普通记忆也按当前任务判适用，不要求实验先开。 */
+export function contextWithTask(context = {}, task = {}) {
+  const out = { ...(context || {}) };
+  if (!task || typeof task !== 'object') return out;
+  if (task.kind && !out.taskKind) out.taskKind = task.kind;
+  if (task.seriesId && !out.seriesId) out.seriesId = task.seriesId;
+  if (task.artifactKey && !out.artifactKey) out.artifactKey = task.artifactKey;
+  if (task.phase && !out.phase) out.phase = task.phase;
+  return out;
+}
+
+export function eligibility(record, runtime = {}, purpose = 'read', now = Date.now()) {
+  if (!record) return { ok: false, status: 'gone', reason: 'gone' };
+  if (record.status === 'archived') return { ok: false, status: 'gone', reason: 'archived' };
+  const pid = runtime && runtime.projectId;
+  if (pid && record.ownerProjectId && record.ownerProjectId !== pid) {
+    return { ok: false, status: 'not_applicable', reason: 'owner_mismatch' };
+  }
+  const experimental = record.origin === 'project_evolution';
+  if (experimental && runtime && runtime.experimental === false) {
+    return { ok: false, status: 'needs_context', reason: 'experimental_disabled' };
+  }
+  const learning = record.learning && typeof record.learning === 'object' ? record.learning : null;
+  if (experimental) {
+    if (!experimentalUsable(record, now)) return { ok: false, status: 'needs_context', reason: 'learning_inactive' };
+    if (learning && (learning.state === 'paused' || learning.blockedReason)) {
+      return { ok: false, status: 'needs_context', reason: 'learning_paused' };
+    }
+  }
+  if (purpose === 'auto' && record.reviewState === 'legacy_unreviewed') {
+    return { ok: false, status: 'needs_context', reason: 'legacy_unreviewed' };
+  }
+  const status = statusOf(record, contextWithTask((runtime && runtime.context) || {}, (runtime && runtime.task) || {}));
+  if (status === 'not_applicable') return { ok: false, status, reason: 'condition_mismatch' };
+  if (purpose === 'auto' && status !== 'ok') return { ok: false, status, reason: 'needs_context' };
+  return { ok: true, status, reason: '' };
+}
+
 /** 旧库迁过来的条目没复核过，先让人看见再决定，不自动注入。 */
 export function canAutoRecall(record, context) {
   if (!record || record.reviewState === 'legacy_unreviewed') return false;
@@ -344,11 +386,26 @@ export function rank(records, query, options = {}) {
   for (const record of records || []) {
     if (!record || record.status === 'archived') continue;
     if (options.requireApplicable && record.reviewState === 'legacy_unreviewed') continue;
-    const status = options.requireApplicable ? statusOf(record, context) : 'ok';
-    if (options.requireApplicable && status !== 'ok') continue;
+    let status;
+    if (options.runtime) {
+      const gate = eligibility(record, options.runtime, options.requireApplicable ? 'auto' : 'search', options.now || Date.now());
+      if (!gate.ok) continue;
+      status = gate.status;
+    } else {
+      status = options.requireApplicable ? statusOf(record, context) : 'ok';
+      if (options.requireApplicable && status !== 'ok') continue;
+    }
     const matched = matchScore(record, query);
     if (matched.score < MATCH_FLOOR) continue;
-    rows.push({ record, score: matched.score, hints: matched.hints, status });
+    /** 当前任务明确的话题/工作类型优先，但不覆盖查询本身的字面命中。 */
+    const task = options.task || {};
+    const sameTask = (record.conditions || []).some((condition) => {
+      if (condition.key === 'taskKind') return task.kind && sameText(condition.value, task.kind);
+      if (condition.key === 'seriesId') return task.seriesId && sameText(condition.value, task.seriesId);
+      if (condition.key === 'artifactKey') return task.artifactKey && sameText(condition.value, task.artifactKey);
+      return false;
+    });
+    rows.push({ record, score: matched.score + (sameTask ? 1.5 : 0), hints: matched.hints, status });
   }
   rows.sort((a, b) => b.score - a.score
     || String(b.record.lastUsed || '').localeCompare(String(a.record.lastUsed || ''))