dsh-lite-memory 0.18.25 → 0.18.27

package/docs/CONVENTIONS.md

@@ -83,9 +83,10 @@
 **范围路由**：模型给的 `scope` 是提案，不是命令。
 
 - 显式 `scope="global"` 表示「用户在这一次对话里要求存全局」，只有用户确实这么说才传；模型自己觉得通用不是理由。显式全局不再因为缺少 `evidenceRef` 被降级。
-- 仍然会拦住的两类：设备事实没有条件（`machine` / `targetOs` / `runtime` / `shell` 至少一个），以及正文或依据里出现本机路径、回环地址、端口的「通用流程」——后者换台机器/换个项目就不成立，留在项目层。
+- 仍然会拦住的两类：设备事实没有条件（`machine` / `targetOs` / `runtime` / `shell` 至少一个），以及正文或依据里写死本机路径、回环地址、端口却没声明适用环境的「通用流程」——后者换台机器/换个项目就不成立，留在项目层。
+- 声明了上述环境条件的本机流程（例如本机特有的命令包装）可以进全局层：条件不成立的机器上不会拿出来用；命令名/工具名本身不算本机痕迹。
 - `memoryClass="project_fact"` 不因写了 `global` 就变全局：项目事实换个项目本来就不成立。
-- 按类别推导（没有显式 `scope`）保持更严：`portable_procedure` 没有 `evidenceRef` 就落项目层。
+- 按类别推导（没有显式 `scope`）保持更严：`portable_procedure` 没有 `evidenceRef`、也没有环境条件时落项目层。
 - 每次降级都要能解释：只在降级时返回 `scopeNote` 一行，说明为什么没进全局、怎么改才进得去；正常落全局或落项目不带这行。
 
 **限额与腾位**：每层活跃条目软上限 200、硬上限 1000；单条正文 4096 字节；单层总字节 1 MiB。到硬上限时把最久没被读的活跃条目移进归档，并在结果里写明「已归档「标题」腾位」，不拒绝新记忆；单条正文超限只报错、不截断。

package/docs/RELEASE-0.18.26.md

@@ -0,0 +1,5 @@
+# 0.18.26
+
+- 只在本机成立、但跨项目复用的命令/流程（例如本机 npm 包装命令）：声明 machine 或 runtime 条件后可以进全局层，换台机器条件不成立就不会拿出来用；仍然写死本机路径/端口又没声明环境的，继续留在项目层。
+- 显式存全局的降级说明补了一句怎么改：补机器条件后可以存全局，不用把规则改写成一个不存在的通用说法。
+- CI 稳定性：召回投影的耗时上限可以在测试里放宽（CI 冷启动偶尔超过 150ms，逻辑断言不该被「这轮先不注入」判失败）；旧库正文比对按行尾归一（Windows 检出把 LF 转成 CRLF）。Windows 与 Ubuntu 六格矩阵全绿。

package/docs/RELEASE-0.18.27.md

@@ -0,0 +1,5 @@
+# 0.18.27
+
+- 可信上下文补上宿主真实平台（`darwin → macos`，`win32 → windows`）：条件写 `targetOs` 的规则从「永远待确认」变成按平台裁决，macOS 上写的本机流程在 macOS 上直接生效。
+- 此前全局层只能收「声明了 machine/runtime 条件」的流程，但条件无从比对；这次把能自动核验的那一维接上，条件不再只是摆设。
+- 召回夹具改用与平台无关的条件，避免 CI 与开发机行为不一致。

package/index.js

@@ -804,7 +804,7 @@ const SAVE_PARAMS = {
       enum: ['distinct'],
       description: '明确表示「这确实是另一条」。返回 needsResolution 时，只有确认不是同一件事才带上它再存一次',
     },
-    scope: { type: 'string', enum: ['auto', 'project', 'global'], description: '存哪一层：auto 按记忆类别判定（默认）；只有用户这一次明确说「以后所有项目都这样」才用 global，模型自己判断通用不是理由；明确说只在这个项目用 project。本机路径/端口和项目事实即使写 global 也会留在项目层，降级原因见 scopeNote' },
+    scope: { type: 'string', enum: ['auto', 'project', 'global'], description: '存哪一层：auto 按记忆类别判定（默认）；只有用户这一次明确说「以后所有项目都这样」才用 global，模型自己判断通用不是理由；明确说只在这个项目用 project。本机路径/端口和项目事实即使写 global 也会留在项目层，降级原因见 scopeNote；只在本机成立的命令/流程声明 machine 或 runtime 条件后可进全局层' },
     memoryClass: { type: 'string', enum: ['personal_preference', 'project_fact', 'environment_fact', 'portable_procedure'], description: '归属提案：个人偏好 / 项目事实 / 设备事实 / 可搬流程。服务端据此判定存哪层；设备事实必须同时给设备条件' },
     durability: { type: 'string', enum: ['durable', 'task'], description: '一般认为 durable；只是一次性任务参数用 task，服务端会拒绝落盘' },
     evidenceRef: { type: 'string', description: '归属判定的依据（哪条消息、哪个文件、哪次观察）；用户没说范围时用来判断能不能存' },
@@ -1015,7 +1015,8 @@ function statusLabel(status) {
  */
 export const RECALL_MODES = ['adaptive', 'tool_only', 'off'];
 const RECALL_QUERY_CHARS = 400;
-const RECALL_DEADLINE_MS = 150;
+/** 单轮投影的耗时上限：慢机器上宁可这轮不注入，也不把回合拖住。测试可临时放宽。 */
+let recallDeadlineMs = 150;
 const RECALL_HEADER = '已有记忆可能相关（需要细节用 memory_read 带标题取正文，别凭标题猜）：';
 
 /** 卡片只放够判断要不要读的几行；必要前提整条在场，装不下就整卡省略。 */
@@ -1992,7 +1993,7 @@ export function apply(ctx, config) {
       /** 显式要了全局却被硬冲突挡回项目层时说清原因：否则模型只能看到 scope=project，无从纠。 */
       const scopeNote = (() => {
         if (args.scope !== 'global' || scope.key === 'global') return '';
-        if (saved.reasonCode === 'machine_bound_scope') return '按本机痕迹留在项目层：正文或依据里写了本机路径/端口，改成别的项目仍成立的通用规则再存全局';
+        if (saved.reasonCode === 'machine_bound_scope') return '按本机痕迹留在项目层：正文或依据里写了本机路径/端口，改成别的项目仍成立的通用规则再存全局；只在本机适用的流程可补 machine 条件后存全局';
         if (saved.reasonCode === 'model_global_project_fact') return '按项目事实留在项目层：换成别的项目就不成立；确实是通用流程就改 memoryClass';
         return '';
       })();
@@ -2706,7 +2707,7 @@ export function apply(ctx, config) {
         return decision;
       }
       /** 超时或被取消：这一步不留半旧卡片，下一真人请求重新投影。 */
-      if (signal?.aborted || Date.now() - startedAt > RECALL_DEADLINE_MS) {
+      if (signal?.aborted || Date.now() - startedAt > recallDeadlineMs) {
         rollbackBudget();
         if (snapshot.cards.length) clearRecall(scope, sessionId);
         clearPrepared(agent);
@@ -3044,6 +3045,8 @@ export function apply(ctx, config) {
       mode: recallMode,
       preparedOf: (agent) => prepared.get(agent) || null,
       windowOf: (agent) => windowOf(agent),
+      /** 测试专用：CI 冷启动偶尔超过 150ms，逻辑测试不该被耗时上限判失败。 */
+      setDeadlineMs: (ms) => { if (Number.isFinite(ms) && ms > 0) recallDeadlineMs = ms; },
     };
     return () => {
       delete globalThis.__liteMemoryRecall;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-lite-memory",
-  "version": "0.18.25",
+  "version": "0.18.27",
   "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

@@ -2520,7 +2520,8 @@ function machineBoundText(source) {
 
 /**
  * 适用范围判定：内容/依据的普适性优先，模型声明的 scope 只是提案。
- * 模型说 global、但正文写死了本机路径或依据是本机文件时，先留在项目层（或问一次条件）。
+ * 写死了本机路径/端口又没有声明适用环境时留在项目层；声明了机器/系统条件的
+ * 本机流程可以进全局层——换台机器条件不成立，自然不会拿出来用。
  */
 export function routeScope(draft, options = {}) {
   const source = draft || {};
@@ -2532,6 +2533,16 @@ export function routeScope(draft, options = {}) {
   const evidence = typeof source.evidenceRef === 'string' ? source.evidenceRef.trim() : '';
   /** 依据本身是本机文件/路径的，不能算通用流程；正文里带本机痕迹同理。 */
   const machineBound = machineBoundText(source) || (evidence ? machineBoundText({ title: evidence }) : false);
+  /** 声明了机器/系统条件，本机痕迹就被这条条件收住：规则仍可搬到所有满足条件的机器上。 */
+  const envScoped = (() => {
+    try {
+      return (view.normalizeConditions(source.conditions) || []).some((item) => ENVIRONMENT_KEYS.includes(item.key));
+    } catch {
+      return false;
+    }
+  })();
+  /** 真正挡回项目层的只有「本机痕迹 + 没有声明适用环境」；只写命令名不算本机痕迹。 */
+  const machineConflict = machineBound && !envScoped;
   const base = { chosenScope: '', reasonCode: '', requiredConditions: [], needsScope: false, explicit };
   /** 通用层拿不出普适证据时：有项目就留在项目层，没有就问一次运行环境。 */
   const fallbackToProject = (reasonCode) => {
@@ -2553,7 +2564,7 @@ export function routeScope(draft, options = {}) {
      * 没显式 scope 时才用 memoryClass 提案，缺可搬依据的流程留在项目层。
      */
     if (explicit === 'global' && !humanConfirmed) {
-      if (machineBound) return fallbackToProject('machine_bound_scope');
+      if (machineConflict) return fallbackToProject('machine_bound_scope');
       if (cls === 'project_fact') return fallbackToProject('model_global_project_fact');
     }
     if (explicit === 'project' && !projectReady) {
@@ -2578,11 +2589,13 @@ export function routeScope(draft, options = {}) {
   }
   if (cls === 'personal_preference') {
     /** 偏好也分「我的习惯」和「这台机器上的习惯」：后者绑机器，不进通用层。 */
-    if (machineBound) return fallbackToProject('machine_bound_preference');
+    if (machineConflict) return fallbackToProject('machine_bound_preference');
     return { ...base, chosenScope: 'global', reasonCode: 'class_personal_preference' };
   }
   if (cls === 'portable_procedure') {
-    if (machineBound) return fallbackToProject('machine_bound_procedure');
+    if (machineConflict) return fallbackToProject('machine_bound_procedure');
+    /** 带适用环境条件的本机流程：条件成立时才用，换台机器自然不生效。 */
+    if (envScoped) return { ...base, chosenScope: 'global', reasonCode: 'machine_scoped_procedure' };
     /** 说能搬去别的项目，就要有能搬的依据；没有就先留在本项目。 */
     if (!evidence) return fallbackToProject('unbound_evidence');
     return { ...base, chosenScope: 'global', reasonCode: 'class_portable_procedure' };

package/test/contract.test.mjs

@@ -460,6 +460,8 @@ const pass = (text, id) => async () => ({
   messages: [{ role: 'user', id, source: { kind: 'user' }, content: [{ type: 'text', text }] }],
 });
 const recall = promptContexts.find((entry) => entry.name === 'lite-memory:recall');
+  /* CI 冷启动偶尔超过召回耗时上限，逻辑断言不该被「这轮先不注入」判失败。 */
+  globalThis.__liteMemoryRecall?.setDeadlineMs?.(5000);
 assert.ok(recall, 'recall context registered');
 assert.equal(recall.order, 60);
 assert.equal(recall.interpolate, false);
@@ -545,6 +547,8 @@ const evoEnter = async () => ({
 });
 await preStep({ agent: evoAgent, signal: evoSig, turn: '21' }, evoEnter);
 const evoRecall = promptContexts.find((entry) => entry.name === 'lite-memory:recall');
+  /* CI 冷启动偶尔超过召回耗时上限，逻辑断言不该被「这轮先不注入」判失败。 */
+  globalThis.__liteMemoryRecall?.setDeadlineMs?.(5000);
 assert.match(evoRecall.text({ agent: evoAgent, signal: evoSig }), /开场三句内给结论/);
 assert.equal(evoRecall.text({ agent: evoAgent, signal: evoSig }).includes('README'), false);
 

package/test/control.test.mjs

@@ -33,6 +33,8 @@ function boot() {
   };
   apply(ctx, { mode: 'adaptive' });
   const provider = promptContexts.find((entry) => entry.name === 'lite-memory:recall');
+  /* CI 冷启动偶尔超过召回耗时上限，逻辑断言不该被「这轮先不注入」判失败。 */
+  globalThis.__liteMemoryRecall?.setDeadlineMs?.(5000);
   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 };

package/test/evolution-read.test.mjs

@@ -35,6 +35,8 @@ function boot(mode = 'adaptive') {
   apply(ctx, { mode });
   const provider = promptContexts.find((entry) => entry.name === 'lite-memory:recall');
   assert.ok(provider, 'recall provider registered');
+  /* CI 冷启动偶尔超过召回耗时上限，逻辑断言不该被「这轮先不注入」判失败。 */
+  globalThis.__liteMemoryRecall?.setDeadlineMs?.(5000);
   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);
   const text = (agent, signal) => provider.text({ agent, signal });

package/test/recall.test.mjs

@@ -39,6 +39,8 @@ function boot(mode = 'adaptive') {
   apply(ctx, { mode });
   const debug = globalThis.__liteMemoryRecall;
   const provider = promptContexts.find((entry) => entry.name === 'lite-memory:recall');
+  /* CI 冷启动偶尔超过召回耗时上限，逻辑断言不该被「这轮先不注入」判失败。 */
+  globalThis.__liteMemoryRecall?.setDeadlineMs?.(5000);
   assert.ok(provider, 'recall provider registered');
   assert.equal(provider.order, 60);
   assert.equal(provider.interpolate, false);
@@ -111,8 +113,8 @@ const linuxOnly = save(scopeA, {
   tags: ['插件', '构建'],
   when: '',
   applicability: 'conditional',
-  conditions: [{ key: 'targetOs', value: 'linux' }],
-  summary: '只在 Linux CI 上跑构建检查',
+  conditions: [{ key: 'machine', value: '别的机器' }],
+  summary: '只在另一台机器上跑构建检查',
 });
 const unresolved = save(scopeA, { title: '发布前要检查什么', tags: ['发布', '检查'], when: '发布前', applicability: 'unresolved' });
 const globalHot = save(global, { title: '插件改动后先热刷新', tags: ['插件', '热刷新'], summary: '全局规矩：先热刷新再谈重启' });
@@ -266,10 +268,10 @@ assert.notEqual(bootA.provider.text({ agent: agentB, signal: signalB }), prepare
   const cwdC = mkdir('c');
   const scopeC = store.scopeOf(cwdC);
   save(scopeC, {
-    title: '只在 Linux 上跑构建检查',
+    title: '只在另一台机器上跑构建检查',
     tags: ['构建'],
     applicability: 'conditional',
-    conditions: [{ key: 'targetOs', value: 'linux' }],
+    conditions: [{ key: 'machine', value: '别的机器' }],
   });
   save(scopeC, { title: '发布前检查清单', tags: ['发布'], when: '发布前', applicability: 'unresolved' });
   const agent = makeAgent('agent-cond', cwdC);

package/test/runtime-context.test.mjs

@@ -33,6 +33,8 @@ function boot(mode = 'adaptive') {
   };
   apply(ctx, { mode });
   const provider = promptContexts.find((entry) => entry.name === 'lite-memory:recall');
+  /* CI 冷启动偶尔超过召回耗时上限，逻辑断言不该被「这轮先不注入」判失败。 */
+  globalThis.__liteMemoryRecall?.setDeadlineMs?.(5000);
   assert.ok(provider, 'recall provider registered');
   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);

package/test/state.test.mjs

@@ -23,6 +23,11 @@ const test = (name, fn) => {
 };
 
 const dirs = [];
+/** Windows 会把同一个临时目录报成 8.3 短名或长名；按目录的文件 ID 判断是不是同一处。 */
+const pathId = (target) => {
+  const stat = fs.statSync(target, { bigint: true });
+  return `${stat.dev}:${stat.ino}`;
+};
 const fresh = (label) => {
   const dir = fs.mkdtempSync(path.join(os.tmpdir(), `lm-state-${label}-`));
   dirs.push(dir);
@@ -218,9 +223,7 @@ test('S01 仓库根与子目录共用一份记忆', () => {
   const atSub = scopeOf(sub);
   assert.equal(atSub.key, atRoot.key);
   assert.equal(atSub.dir, atRoot.dir);
-  /* Windows reports the temp root as an 8.3 short name on one side and the long
-     name on the other; compare what both of them resolve to. */
-  assert.equal(fs.realpathSync(resolveRoot(sub).root), fs.realpathSync(repo));
+  assert.equal(pathId(resolveRoot(sub).root), pathId(repo));
 });
 
 test('S02 符号链接、非 Git 目录、嵌套仓库各归各的', () => {
@@ -251,7 +254,7 @@ test('S03 配置的项目根只覆盖自己的子树，不吞别的目录', () =
   fs.mkdirSync(path.dirname(config), { recursive: true });
   fs.writeFileSync(config, JSON.stringify({ projectRoot: root }));
   try {
-    assert.equal(resolveRoot(sub).root, fs.realpathSync(root));
+    assert.equal(pathId(resolveRoot(sub).root), pathId(root));
     assert.equal(resolveRoot(sub).source, 'configured');
     assert.equal(scopeOf(sub).key, scopeOf(root).key);
     assert.notEqual(resolveRoot(outside).source, 'configured');
@@ -327,7 +330,7 @@ test('S10 旧库迁移：正文、归档、旧标题一起搬进状态', () => {
   const loaded = load(scope).state;
   assert.equal(loaded.entries.length, 4);
   assert.equal(loaded.migration.fromVersion, 1);
-  assert.equal(bodyOf(scope, 'mem_111111111111'), '第一步跑测试\n第二步改版本号');
+  assert.equal(bodyOf(scope, 'mem_111111111111').replace(/\r\n/g, '\n'), '第一步跑测试\n第二步改版本号');
   const archived = loaded.entries.find((entry) => entry.id === 'mem_444444444444');
   assert.equal(archived.status, 'archived');
   assert.equal(archived.current.body, '归档正文');

package/test/store.test.mjs

@@ -1089,6 +1089,24 @@ test('归属路由：本机痕迹的「通用流程」留在项目层，干净
   assert.equal(evidencePath.chosenScope, 'project', '依据本身是本机文件不算普适证据');
   assert.equal(evidencePath.reasonCode, 'machine_bound_procedure');
 
+  const scopedProcedure = store.routeScope({
+    title: 'npm 操作走 dsh-npm', summary: '本机 npm 命令用包装脚本',
+    body: '本机 npm 一律用 dsh-npm；裸 npm 报 ENEEDAUTH 不是缺凭据',
+    memoryClass: 'portable_procedure',
+    conditions: [{ key: 'machine', value: 'macOS 桌面机' }],
+  }, { project });
+  assert.equal(scopedProcedure.chosenScope, 'global', '声明了机器条件的本机流程可进全局层');
+  assert.equal(scopedProcedure.reasonCode, 'machine_scoped_procedure');
+
+  const scopedExplicit = store.routeScope({
+    title: 'npm 操作走 dsh-npm', summary: '本机 npm 命令用包装脚本',
+    body: '本机 npm 一律用 dsh-npm；裸 npm 报 ENEEDAUTH 不是缺凭据',
+    memoryClass: 'portable_procedure', scope: 'global',
+    conditions: [{ key: 'machine', value: 'macOS 桌面机' }],
+  }, { project });
+  assert.equal(scopedExplicit.chosenScope, 'global');
+  assert.equal(scopedExplicit.reasonCode, 'explicit');
+
   const unconfirmed = store.routeScope({
     title: '部署脚本', summary: '本机部署脚本', body: 'bash /tmp/deploy.sh',
     memoryClass: 'portable_procedure', scope: 'global',

package/test/view.test.mjs

@@ -70,7 +70,11 @@ test('条件裁决：不把不知道当不存在，也不把未解决当普遍
   const record = { id: 'mem_000000000001', applicability: 'conditional', conditions: [{ key: 'targetOs', value: 'macOS' }], when: '' };
   assert.equal(view.evaluate(record, ctxOf(null, { targetOs: 'macos' })).state, 'match');
   assert.equal(view.evaluate(record, ctxOf(null, { targetOs: 'linux' })).state, 'mismatch');
-  assert.equal(view.evaluate(record, ctxOf(null, {})).state, 'unknown');
+  assert.equal(ctxOf(null, {}).targetOs, view.hostTargetOs());
+  const hostRecord = { ...record, conditions: [{ key: 'targetOs', value: view.hostTargetOs() || 'macos' }] };
+  assert.equal(view.evaluate(hostRecord, ctxOf(null, {})).state, 'match');
+  const machineOnly = { ...record, conditions: [{ key: 'machine', value: '这台机器' }] };
+  assert.equal(view.evaluate(machineOnly, ctxOf(null, {})).state, 'unknown');
   const unresolved = { ...record, applicability: 'unresolved', conditions: [] };
   assert.equal(view.statusOf(unresolved, ctxOf(null, {})), 'needs_context');
   assert.equal(view.canAutoRecall(unresolved, ctxOf(null, {})), false);

package/view.js

@@ -152,7 +152,8 @@ export function validateApplicability(applicability, conditions, selection, when
 export function trustedContext(scope, options = {}) {
   const cwd = typeof options.cwd === 'string' && options.cwd ? options.cwd : (scope && scope.cwd) || '';
   return {
-    targetOs: options.targetOs,
+    /** 宿主的真实平台是可信上下文：条件里写 targetOs 的规则本职就是按平台生效。 */
+    targetOs: options.targetOs === undefined ? hostTargetOs() : options.targetOs,
     shell: options.shell,
     runtime: options.runtime,
     machine: options.machine,
@@ -166,6 +167,15 @@ export function trustedContext(scope, options = {}) {
   };
 }
 
+/** 只报归一化后的平台名；未知平台不硬猜，留给条件判 unknown。 */
+export function hostTargetOs() {
+  const platform = typeof process !== 'undefined' && process ? process.platform : '';
+  if (platform === 'darwin') return 'macos';
+  if (platform === 'win32') return 'windows';
+  if (platform === 'linux') return 'linux';
+  return '';
+}
+
 function sameText(left, right) {
   return plain(left, PATH_CHARS).toLowerCase() === plain(right, PATH_CHARS).toLowerCase();
 }