dsh-lite-memory 0.18.31 → 0.18.33

package/docs/RELEASE-0.18.32.md

@@ -0,0 +1,8 @@
+# 0.18.32
+
+## 归属判定：操作系统名收不住本机痕迹
+
+- 正文或依据里出现本机路径、回环地址、端口时，只有 `machine` / `runtime` 条件才算把这条规则收在具体环境里。
+- 只写 `targetOs`（例如 `macos`）不再让本机脚本升到全局层：换一台同系统的机器，路径仍然不存在。
+- 干净的跨项目流程只声明平台条件时仍可进全局层，平台条件按可信上下文生效。
+- 回归覆盖：`test/store.test.mjs` 新增「只写操作系统名收不住本机路径」两类用例。

package/docs/RELEASE-0.18.33.md

@@ -0,0 +1,7 @@
+# 0.18.33：作品规则不串到别的任务
+
+- 作品里学到的规范自动带上当时的任务范围：模型写成「全项目」也收窄成任务条件，不再一条代码习惯跑进数据库任务。
+- 收集时固定的任务范围只补不丢：整理器漏写时补回，写成别的条件时自动合并，不整条作废。
+- 生命周期先于适用范围：归档、被取代、过期的条目读取时如实报状态，不再显示成现行规则，也不回写 `lastUsed`。
+- 空正文读取只回标题与状态，不占正文额度、不计引用、不算「用过」。
+- 没有可用模型时不先扣自进化滚动额度，避免扣了却发不出调用。

package/index.js

@@ -2449,6 +2449,8 @@ export function apply(ctx, config) {
       }
       const revision = record.revision || 1;
       const body = String(record.body ?? '');
+      /** 空正文只回标题与状态：没有正文可交付，就不占正文额度、不算引用。 */
+      const hasBody = body.trim() !== '';
       const value = {
         title: record.title,
         when: record.when || '',
@@ -2474,14 +2476,14 @@ export function apply(ctx, config) {
           return receipt;
         }
         const bytes = jsonBytes(value);
-        if (!affordableTool(win, bytes, 1)) return { scope: '', status: 'budget_exhausted' };
+        if (!affordableTool(win, bytes, hasBody ? 1 : 0)) return { scope: '', status: 'budget_exhausted' };
         win.bytes += bytes;
         win.toolBytes += bytes;
-        win.bodies += 1;
+        if (hasBody) win.bodies += 1;
         win.reads += 1;
-        win.readBodies.set(record.id, revision);
+        if (hasBody) win.readBodies.set(record.id, revision);
       }
-      recordCitations(scope, sessionIdOf(execution), [record]);
+      if (hasBody) recordCitations(scope, sessionIdOf(execution), [record]);
       return value;
     },
   }), 'lite-memory: memory_read');
@@ -2959,6 +2961,9 @@ export function apply(ctx, config) {
     const operationId = `learn_${crypto.createHash('sha256')
       .update(`${scope.key}|${candidate.episodeId}|${candidate.messageIds.join(',')}`)
       .digest('hex').slice(0, 16)}`;
+    /** 没有可用模型就别先扣滚动额度：扣了却发不出调用，额度会白烧一整窗口。 */
+    const llm = getService('llm');
+    if (!llm || typeof llm.prepareCall !== 'function') return;
     const begin = beginLearningAttempt(scope, { episodeId: candidate.episodeId, operationId: `${operationId}_start`, now: Date.now() });
     if (!begin || begin.ok !== true || begin.replayed) return;
     const ranges = rangesOf(scope);
@@ -2977,11 +2982,6 @@ export function apply(ctx, config) {
       revision: record.revision || 1,
       specDigest: learning.specDigestOf(record),
     }));
-    const llm = getService('llm');
-    if (!llm || typeof llm.prepareCall !== 'function') {
-      recordLearningFailure(scope, { operationId: `${operationId}_fail`, episodeId: candidate.episodeId, reason: '宿主没有可用模型', epoch: begin.epoch });
-      return;
-    }
     const controller = new AbortController();
     learningAborts.set(scope.key, controller);
     const deadline = setTimeout(() => { try { controller.abort(); } catch { /* already aborted */ } }, learning.LIMITS.timeoutMs);

package/learning.js

@@ -626,6 +626,18 @@ export function validateChange(change, { refs, rules, ranges, expectedTarget } =
   const expectedConditions = ['taskKind', 'seriesId', 'phase']
     .filter((key) => String(expected?.[key] || '').trim())
     .map((key) => ({ key, value: String(expected[key]).trim() }));
+  /** 作品里学到的规范必须带上当时的任务范围：模型想写成全项目时收窄成条件规则，而不是丢掉这条反馈。 */
+  const narrowToEpisode = target === 'new' && expected?.scope === 'episode' && expectedConditions.length > 0;
+  if (narrowToEpisode) {
+    if (applicability === undefined || applicability === 'all_in_scope') applicability = 'conditional';
+    const merged = conditions !== undefined ? [...conditions] : [];
+    for (const row of expectedConditions) {
+      if (merged.some((item) => item.key === row.key && item.value === row.value)) continue;
+      if (!conditionValueAllowed(row, { ranges, existing })) return { ok: false, reason: '收集时的任务范围不在本项目里' };
+      merged.push(row);
+    }
+    conditions = merged;
+  }
   const expectedApplicability = expected
     ? (expected.applicability === 'all_in_scope'
       ? 'all_in_scope'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-lite-memory",
-  "version": "0.18.31",
+  "version": "0.18.33",
   "description": "On-demand memory for the DeepSeek Harness: nothing resident, at most three small cards on a real hit, bodies read on demand.",
   "type": "module",
   "main": "index.js",

package/store.js

@@ -1653,23 +1653,27 @@ export function readEntry(scope, id, options = {}) {
       if (!record && !archived) continue;
       if (!readableRecord(record || archived, options, index)) continue;
       const body = readBody(source, id);
+      /** 生命周期先判定：过期/被取代的条目不能再报成现行规则。 */
+      const lifecycle = view.lifecycleStatusOf(record || archived, options.now || Date.now());
       return {
         source,
         archived: Boolean(archived),
+        lifecycle,
         record: {
           ...(record || archived),
           scope: source.key === 'global' ? 'global' : 'project',
           body,
-          status: archived ? 'archived' : view.statusOf(record, options.context || {}),
+          status: lifecycle || view.statusOf(record, options.context || {}),
         },
       };
     }
     return null;
   });
   if (!found) return null;
-  /** 读过才算用过；归档、被取代、过期或条件不匹配的读取都不算「在用」。 */
+  /** 读过才算用过；归档、被取代、过期、空正文或条件不匹配的读取都不算「在用」。 */
   const countsAsUsage = typeof options.usage !== 'function' || options.usage(found.record) !== false;
-  if (!found.archived && countsAsUsage) touchUsed(found.source, [id]);
+  const hasBody = typeof found.record.body === 'string' && found.record.body.trim() !== '';
+  if (!found.archived && !found.lifecycle && hasBody && countsAsUsage) touchUsed(found.source, [id]);
   return found.record;
 }
 
@@ -2507,6 +2511,8 @@ export const MEMORY_CLASSES = ['personal_preference', 'project_fact', 'environme
 export const DURABILITIES = ['durable', 'task'];
 
 const ENVIRONMENT_KEYS = ['machine', 'targetOs', 'runtime', 'shell'];
+/** 一台机器/一次运行才算收住本机痕迹；只写操作系统名（targetOs）换台机器照样不成立。 */
+const MACHINE_SCOPE_KEYS = ['machine', 'runtime'];
 
 /**
  * 范围路由：用户明确说的范围最高；没有就按记忆类别提案，设备事实必须带设备条件。
@@ -2568,8 +2574,16 @@ export function routeScope(draft, options = {}) {
       return false;
     }
   })();
+  /** 本机痕迹只被「本机/运行时」条件收住；targetOs 是平台，不是这台机器。 */
+  const machineScoped = (() => {
+    try {
+      return (view.normalizeConditions(source.conditions) || []).some((item) => MACHINE_SCOPE_KEYS.includes(item.key));
+    } catch {
+      return false;
+    }
+  })();
   /** 真正挡回项目层的只有「本机痕迹 + 没有声明适用环境」；只写命令名不算本机痕迹。 */
-  const machineConflict = machineBound && !envScoped;
+  const machineConflict = machineBound && !machineScoped;
   const base = { chosenScope: '', reasonCode: '', requiredConditions: [], needsScope: false, explicit };
   /** 通用层拿不出普适证据时：有项目就留在项目层，没有就问一次运行环境。 */
   const fallbackToProject = (reasonCode) => {

package/test/learning.test.mjs

@@ -8,6 +8,7 @@ const store = await import('../store.js');
 const learning = await import('../learning.js');
 const anchor = await import('../anchor.js');
 const state = await import('../state.js');
+const view = await import('../view.js');
 
 let passed = 0;
 const test = (name, fn) => {
@@ -996,18 +997,45 @@ test('L03d 作用域在收集时固定，整理只能沿用或收窄', () => {
   assert.equal(learning.validateChange({ ...base, applicability: 'all_in_scope' }, { refs, rules: [], ranges: RANGES, expectedTarget: wide.expectedTarget }).ok, true);
 
   const video = { scope: 'episode', episodeId: 'ep_x', taskKind: 'video' };
+  /** 作品里学到的规范：想说成全项目时收窄成任务条件，而不是整条作废。 */
   const episodeWide = learning.validateChange({ ...base, applicability: 'all_in_scope' }, { refs, rules: [], ranges: RANGES, expectedTarget: video });
-  assert.equal(episodeWide.ok, false, '作品规则不能抬成全项目');
+  assert.equal(episodeWide.ok, true, episodeWide.reason);
+  assert.equal(episodeWide.change.applicability, 'conditional');
+  assert.deepEqual(episodeWide.change.conditions, [{ key: 'taskKind', value: 'video' }]);
   const droppedKind = learning.validateChange({ ...base, applicability: 'conditional', conditions: [{ key: 'phase', value: 'script' }] }, { refs, rules: [], ranges: RANGES, expectedTarget: video });
-  assert.equal(droppedKind.ok, false, '不能删掉收集时的任务范围');
+  assert.equal(droppedKind.ok, true, droppedKind.reason);
+  assert.deepEqual(droppedKind.change.conditions, [{ key: 'phase', value: 'script' }, { key: 'taskKind', value: 'video' }], '缺的任务范围自动补回，不能丢');
   const keptKind = learning.validateChange({ ...base, applicability: 'conditional', conditions: [{ key: 'taskKind', value: 'video' }, { key: 'phase', value: 'script' }] }, { refs, rules: [], ranges: RANGES, expectedTarget: video });
   assert.equal(keptKind.ok, true, keptKind.reason);
+  assert.deepEqual(keptKind.change.conditions, [{ key: 'taskKind', value: 'video' }, { key: 'phase', value: 'script' }]);
 
   const fallback = learning.pendingChangeFrom({ text: '以后所有开头都先给结论。', cue: { explicitLongTerm: true }, expectedTarget: narrow.expectedTarget });
   assert.equal(fallback.applicability, 'unresolved', '兜底不重新推导作用域');
   assert.equal(learning.pendingChangeFrom({ text: '以后开头都先给结论。', cue: { explicitLongTerm: true }, expectedTarget: wide.expectedTarget }).applicability, 'all_in_scope');
 });
 
+test('L03d2 代码任务学到的规则不会在数据库任务里生效', () => {
+  const refs = { feedback: { u0: 'm1' }, rules: {} };
+  const parsed = learning.parseOutput(JSON.stringify({
+    changes: [{
+      target: 'new', feedbackType: 'spec_change', topicKey: '迁移',
+      currentText: '先跑迁移再改代码', applicability: 'all_in_scope', evidence: ['u0'],
+    }],
+  }), {
+    finish: { kind: 'stop' }, refs, rules: [], ranges: { ...RANGES, taskKinds: ['code', 'database'] },
+    expectedTarget: { scope: 'episode', projectId: 'p', episodeId: 'ep_code', taskKind: 'code' },
+  });
+  assert.equal(parsed.ok, true, parsed.reason);
+  const change = parsed.changes[0];
+  assert.equal(change.applicability, 'conditional');
+  assert.deepEqual(change.conditions, [{ key: 'taskKind', value: 'code' }]);
+  const code = view.eligibility({ id: 'mem_1', title: '迁移', status: 'active', origin: 'project_evolution', conditions: change.conditions, learning: { state: 'active' } }, { task: { kind: 'code' } }, 'auto');
+  const db = view.eligibility({ id: 'mem_1', title: '迁移', status: 'active', origin: 'project_evolution', conditions: change.conditions, learning: { state: 'active' } }, { task: { kind: 'database' } }, 'auto');
+  assert.equal(code.ok, true);
+  assert.equal(db.ok, false);
+  assert.equal(db.reason, 'condition_mismatch');
+});
+
 test('L03e 先按相关性排序再截断，输入顺序不挤掉真正相关的旧规则', () => {
   const rules = [];
   for (let index = 0; index < 32; index += 1) {

package/test/store.test.mjs

@@ -162,6 +162,28 @@ test('expired or superseded records do not block a new same-title save', () => {
   assert.notEqual(replacement.record.id, second.record.id);
 });
 
+test('expired reads report their lifecycle and empty reads do not count as usage', () => {
+  const scope = fresh('lifecycle-read');
+  const first = upsert(scope, { title: '过期条目', summary: '已经过了有效期', body: '旧正文' });
+  const index = loadIndex(scope);
+  index.entries.find((row) => row.id === first.record.id).validUntil = new Date(Date.now() - 1000).toISOString();
+  index.entries.find((row) => row.id === first.record.id).lastUsed = '2026-01-01T00:00:00.000Z';
+  saveIndex(scope, index);
+  const expired = readEntry(scope, first.record.id);
+  assert.equal(expired.status, 'expired');
+  assert.equal(expired.body, '旧正文');
+  assert.equal(loadIndex(scope).entries.find((row) => row.id === first.record.id).lastUsed, '2026-01-01T00:00:00.000Z');
+
+  const empty = upsert(scope, { title: '空正文条目', summary: '只有摘要', body: '' }).record;
+  loadIndex(scope).entries.find((row) => row.id === empty.id).lastUsed = '2026-01-01T00:00:00.000Z';
+  const saved = loadIndex(scope);
+  saved.entries.find((row) => row.id === empty.id).lastUsed = '2026-01-01T00:00:00.000Z';
+  saveIndex(scope, saved);
+  const record = readEntry(scope, empty.id);
+  assert.equal(record.body, '');
+  assert.equal(loadIndex(scope).entries.find((row) => row.id === empty.id).lastUsed, '2026-01-01T00:00:00.000Z', '空读不算用过');
+});
+
 test('oversized body is rejected, old data untouched', () => {
   const scope = fresh('oversize');
   const big = 'x'.repeat(LIMITS.entryBytes + 1);
@@ -1089,6 +1111,22 @@ test('归属路由：本机痕迹的「通用流程」留在项目层，干净
   assert.equal(evidencePath.chosenScope, 'project', '依据本身是本机文件不算普适证据');
   assert.equal(evidencePath.reasonCode, 'machine_bound_procedure');
 
+  const osOnlyProcedure = store.routeScope({
+    title: '本机部署脚本', summary: '本机部署脚本的位置', body: 'bash /tmp/deploy.sh',
+    memoryClass: 'portable_procedure', scope: 'global',
+    conditions: [{ key: 'targetOs', value: 'macos' }],
+  }, { project });
+  assert.equal(osOnlyProcedure.chosenScope, 'project', '只写操作系统名收不住本机路径');
+  assert.equal(osOnlyProcedure.reasonCode, 'machine_bound_scope');
+
+  const osOnlyClass = store.routeScope({
+    title: '本机部署脚本', summary: '本机部署脚本的位置', body: 'bash /tmp/deploy.sh',
+    memoryClass: 'portable_procedure',
+    conditions: [{ key: 'targetOs', value: 'macos' }],
+  }, { project });
+  assert.equal(osOnlyClass.chosenScope, 'project', 'targetOs 不是机器条件，不能凭它搬去全局层');
+  assert.equal(osOnlyClass.reasonCode, 'machine_bound_procedure');
+
   const scopedProcedure = store.routeScope({
     title: 'npm 操作走 dsh-npm', summary: '本机 npm 命令用包装脚本',
     body: '本机 npm 一律用 dsh-npm；裸 npm 报 ENEEDAUTH 不是缺凭据',

package/view.js

@@ -241,13 +241,19 @@ export function contextWithTask(context = {}, task = {}) {
   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' };
-  /** 生命周期与手动检索共用一条：被取代或过期的条目不再像现行规则一样进入召回和正文读取。 */
-  if (record.supersededBy) return { ok: false, status: 'gone', reason: 'superseded' };
+/** 生命周期先于适用范围：归档、被取代、过期这三类都不该再算现行规则。 */
+export function lifecycleStatusOf(record, now = Date.now()) {
+  if (!record) return 'gone';
+  if (record.status === 'archived') return 'archived';
+  if (record.supersededBy) return 'superseded';
   const validUntil = Date.parse(record.validUntil || '');
-  if (Number.isFinite(validUntil) && validUntil <= now) return { ok: false, status: 'gone', reason: 'expired' };
+  if (Number.isFinite(validUntil) && validUntil <= now) return 'expired';
+  return '';
+}
+
+export function eligibility(record, runtime = {}, purpose = 'read', now = Date.now()) {
+  const lifecycle = lifecycleStatusOf(record, now);
+  if (lifecycle) return { ok: false, status: 'gone', reason: lifecycle };
   const pid = runtime && runtime.projectId;
   if (pid && record.ownerProjectId && record.ownerProjectId !== pid) {
     return { ok: false, status: 'not_applicable', reason: 'owner_mismatch' };