dsh-lite-memory 0.18.26 → 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.27.md

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-lite-memory",
-  "version": "0.18.26",
+  "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/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/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/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();
 }