@jjh32456/dsh-longlive 1.6.7 → 1.6.8

package/test/fixtures/activity-append-child.mjs

@@ -0,0 +1,29 @@
+// Child process used by test/activity-stream.test.mjs to prove that two
+// processes appending to the same board produce unique, contiguous seq values.
+// Usage: node activity-append-child.mjs <memoryRoot> <sessionId> <count> <tag>
+
+import crypto from 'node:crypto';
+
+import { createActivityStore } from '../../src/activity/store.js';
+
+const [memoryRoot, sessionId, countText, tag] = process.argv.slice(2);
+const count = Number(countText);
+if (!memoryRoot || !sessionId || !Number.isInteger(count) || count < 1) {
+  console.error(JSON.stringify({ ok: false, error: 'bad-args' }));
+  process.exit(2);
+}
+const store = createActivityStore({ memoryRoot });
+for (let index = 0; index < count; index += 1) {
+  const result = store.append({
+    sessionId,
+    kind: 'doing',
+    // Deliberately dissimilar texts: this test is about append/lock, not dedupe.
+    text: `${tag} 独立任务 ${index} ${crypto.randomUUID()}`,
+    key: `${tag}|task-${index}`,
+  });
+  if (!result.ok) {
+    console.error(JSON.stringify({ ok: false, index, code: result.code }));
+    process.exit(3);
+  }
+}
+console.log(JSON.stringify({ ok: true, count }));

package/test/live.test.mjs

@@ -198,7 +198,7 @@ export async function runLiveSuite({ runCase, runAsyncCase, runSymlinkCase, asse
   });
 
   // L1 — round-trip, exact field set, patch semantics, goal truncation.
-  runCase('L1', '写读往返：14 字段齐全，patch 保留旧值，goal 截断并标注', () => {
+  runCase('L1', '写读往返：15 字段齐全，patch 保留旧值，goal 截断并标注', () => {
     const root = newRoot(TMP, 'l1');
     const sessionId = 's-l1';
     const longGoal = '一二三四五六七八九十'.repeat(9); // 90 code points
@@ -231,17 +231,19 @@ export async function runLiveSuite({ runCase, runAsyncCase, runSymlinkCase, asse
     // that drops a field pass, because the expectation would move with it.
     const DOCUMENTED_FIELDS = [
       'schemaVersion', 'sessionId', 'pid', 'host', 'startedAt', 'updatedAt', 'heartbeatAt',
-      'ttlMs', 'state', 'turn', 'goal', 'blocked_on', 'queued', 'last_action',
+      'ttlMs', 'state', 'turn', 'goal', 'goalUpdatedAt', 'blocked_on', 'queued', 'last_action',
     ];
     assert(
       JSON.stringify(Object.keys(stored)) === JSON.stringify(DOCUMENTED_FIELDS),
-      `stored row must be exactly the 14 documented fields in order, got ${JSON.stringify(Object.keys(stored))}`,
+      `stored row must be exactly the 15 documented fields in order, got ${JSON.stringify(Object.keys(stored))}`,
     );
     assert(stored.schemaVersion === LIVE_SCHEMA_VERSION, 'schemaVersion');
     assert(stored.pid === process.pid, 'pid must be the writing process');
     assert(stored.host === HOST, 'host must be this machine');
     assert(stored.startedAt === iso(NOW), 'startedAt = now');
     assert(stored.updatedAt === iso(NOW) && stored.heartbeatAt === iso(NOW), 'updatedAt/heartbeatAt = now');
+    // R3: the goal has its own clock; a heartbeat touch must never move it.
+    assert(stored.goalUpdatedAt === iso(NOW), 'goalUpdatedAt = the goal write time');
     assert(stored.state === 'blocked', 'state');
     assert(stored.turn === 7, 'turn');
     assert(stored.blocked_on === 'waiting for review', 'blocked_on while blocked');
@@ -262,6 +264,7 @@ export async function runLiveSuite({ runCase, runAsyncCase, runSymlinkCase, asse
     const patched = second.record;
     assert(patched.turn === 7, 'turn preserved by patch');
     assert(patched.goal === stored.goal, 'goal preserved by patch');
+    assert(patched.goalUpdatedAt === iso(NOW), 'goalUpdatedAt preserved by a goal-less patch');
     assert(JSON.stringify(patched.queued) === JSON.stringify(['a', 'b', 'c']), 'queued preserved');
     assert(patched.blocked_on === '', 'blocked_on emptied');
     assert(patched.startedAt === iso(NOW), 'startedAt preserved across updates');

package/test/packaging.test.mjs

@@ -11,6 +11,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { VERSION } from '../src/version.js';
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.resolve(HERE, '..');
@@ -140,17 +141,18 @@ test('只带白名单安装后：没有 prototype，所有 src 相对 import 都
   assert.deepEqual(offenders, [], `存在跨出包目录/缺失的 import：\n${offenders.join('\n')}`);
 });
 
-test('R2-07 发布版本面：包版本 1.6.5，文档同步 D2/D6 能力集', () => {
-  assert.equal(PKG.version, '1.6.5');
+test(`R2-07 发布版本面：包版本 ${VERSION} + 活动流，文档同步 D2/D6 能力集`, () => {
+  assert.equal(PKG.version, VERSION);
   const read = (rel) => fs.readFileSync(path.join(ROOT, rel), 'utf8');
   const en = read('docs/README.en.md');
-  assert.ok(en.includes('@jjh32456/dsh-longlive-panel@0.2.5'), '面板版本未统一到 0.2.5（scoped 包名）');
-  assert.ok(en.includes('jjh32456-dsh-longlive-1.6.5.tgz'), '英文文档示例 tgz 不是 scoped 的 1.6.5');
+  assert.ok(en.includes('@jjh32456/dsh-longlive-panel@0.2.6'), '面板版本未统一到 0.2.6（scoped 包名）');
+  assert.ok(en.includes(`jjh32456-dsh-longlive-${VERSION}.tgz`), `英文文档示例 tgz 不是 scoped 的 ${VERSION}`);
   assert.ok(en.includes('@jjh32456/dsh-longlive'), '英文文档缺少 scoped 包名');
   assert.equal(en.includes('dsh-longlive-panel@0.1.3'), false, '英文文档仍残留 0.1.3');
   assert.equal(en.includes('0.9.0-rc.1'), false, '英文文档仍残留 rc.1');
   const features = read('docs/FEATURES.md');
-  assert.ok(features.startsWith('# 1.6.5'), 'FEATURES.md 标题不是 1.6.5');
+  assert.ok(features.startsWith(`# ${VERSION}`), `FEATURES.md 标题不是 # ${VERSION}`);
+  assert.ok(features.includes('sharedBrain.activity'), 'FEATURES.md 未记录活动流开关');
   assert.equal(features.includes('0.9.0-rc.1'), false, 'FEATURES.md 仍残留 rc.1');
 });
 

package/test/router-background/router.test.mjs

@@ -46,6 +46,20 @@ function makeCase({ tasks = [], queueText = null, memory = null, llm = null, rou
 
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
+// 「挂住」防线，不依赖墙钟精度：只把无限等待变成显式失败，阈值远高于负载抖动
+// （本套件单测观测到的最高耗时约 2.2s，这里取 10s）。正常路径会清掉定时器。
+async function withHangGuard(promise, ms, label) {
+  let timer = null;
+  const guard = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`${label} 超过 ${ms}ms 仍未收敛（疑似 stop/tick 挂住回归）`)), ms);
+  });
+  try {
+    return await Promise.race([promise, guard]);
+  } finally {
+    if (timer) clearTimeout(timer);
+  }
+}
+
 after(() => {
   try { fs.rmSync(TMP, { recursive: true, force: true }); } catch { /* best effort */ }
 });
@@ -890,11 +904,12 @@ test('P10/P08：iterator.return() 永不 resolve 时 tick 仍能收敛，busy/
       }
     },
   };
+  const CALL_TIMEOUT_MS = 2000;
   const r = c.router({
     llm,
     maxTokens: 200,
     callMaxTokens: 50,
-    callTimeoutMs: 5000,
+    callTimeoutMs: CALL_TIMEOUT_MS,
     stopTimeoutMs: 500,
     retry: { maxAttempts: 1 },
   });
@@ -905,22 +920,28 @@ test('P10/P08：iterator.return() 永不 resolve 时 tick 仍能收敛，busy/
   const started = Date.now();
   const stopRes = await r.stop();
   const stopElapsed = Date.now() - started;
-  const tickRes = await tickPromise;
+  const tickRes = await withHangGuard(tickPromise, 10000, 'P10 tick');
   const settleElapsed = Date.now() - started;
 
-  assert.equal(stopRes.timedOut, false, 'stop 不能因为 return() 挂住');
-  // 只量 stop() 本身；旧写法把 tick 收敛也算了进去，CI 抖动时会偶发 551ms。
-  // 断言保留，放宽一个明确的调度余量（stopTimeoutMs + 150ms）。
+  // 真回归防线：旧实现 await iterator.return() 无限期，stop/tick 会一直挂住。
+  // 这里只要求 stop 在单次调用预算（callTimeout，2s 级）内返回，并对 tick 收敛
+  // 给同样量级的上界；**不再**贴着 stopTimeoutMs（500ms）断言——负载下定时器
+  // 回调被调度挤压时 stop 合法地走 timedOut 分支（实测偶发 ~1.3s），那不是回归。
+  // 若 stop 真的挂住（回到 await return()），elapsed 会远超 CALL_TIMEOUT_MS。
   assert.ok(
-    stopElapsed <= 500 + 150,
-    `stop 必须在 stopTimeoutMs（500ms）附近收敛，允许 150ms 调度抖动（实测 ${stopElapsed}ms）`,
+    stopElapsed <= CALL_TIMEOUT_MS,
+    `stop 必须在 callTimeout 预算（${CALL_TIMEOUT_MS}ms）内返回，实测 ${stopElapsed}ms`,
   );
-  assert.ok(settleElapsed < 2000, `tick 必须在 stop 后很快收敛（实测 ${settleElapsed}ms）`);
+  assert.equal(stopRes.state, 'stopped', 'stop 返回后状态必须停在 stopped');
+  assert.equal(r.state, 'stopped');
+  assert.ok(settleElapsed <= CALL_TIMEOUT_MS + 1000, `tick 必须在 stop 后收敛，实测 ${settleElapsed}ms`);
   assert.equal(tickRes.ok, true);
   assert.equal(r.busy, false, 'busy 必须释放');
   assert.equal(r.reservedTokens, 0);
   assert.equal(r.ledger.snapshot().reserved, 0, '预留必须释放，不能泄漏 50');
-  assert.equal(returned, false, '生成器 finally 可能来不及跑，但 tick 不能等它');
+  // `returned` 只作诊断：生成器 finally 可能来得及跑、也可能被丢下；关键是
+  // stop/tick 不许等它——上面的时间上界就是这条防线，故不在此断言它的值。
+  void returned;
   await r.dispose();
 });
 
@@ -942,22 +963,33 @@ test('P08：正常 abort 时消费端走到 drain 并关闭迭代器（finally
       }
     },
   };
+  const CALL_TIMEOUT_MS = 2000;
   const r = c.router({
     llm,
     maxTokens: 200,
     callMaxTokens: 50,
-    stopTimeoutMs: 500,
+    callTimeoutMs: CALL_TIMEOUT_MS,
+    // 2s 预算：正常 abort 的 drain 是确定性的，不该由 500ms 定时器抖动决定成败。
+    stopTimeoutMs: 2000,
     retry: { maxAttempts: 1 },
   });
   r.start();
   const tickPromise = r.tick();
   await sleep(40);
+  const started = Date.now();
   const stopRes = await r.stop();
-  await tickPromise;
+  const stopElapsed = Date.now() - started;
+  const tickRes = await withHangGuard(tickPromise, 10000, 'P08 tick');
 
-  assert.equal(stopRes.timedOut, false);
+  assert.ok(
+    stopElapsed <= CALL_TIMEOUT_MS,
+    `stop 必须在 callTimeout 预算（${CALL_TIMEOUT_MS}ms）内返回，实测 ${stopElapsed}ms`,
+  );
+  assert.equal(stopRes.state, 'stopped');
+  assert.equal(tickRes.ok, true, 'tick 必须收敛（不能被 abort 拖挂）');
   assert.equal(returned, true, 'abort 之后必须真正关闭生成器');
   assert.ok(pulled >= 1);
+  assert.equal(r.busy, false);
   assert.equal(r.ledger.snapshot().reserved, 0);
   await r.dispose();
 });

package/test/run-rc.mjs

@@ -14,6 +14,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { VERSION } from '../src/version.js';
 
 const HERE = path.dirname(fileURLToPath(import.meta.url));
 const ROOT = path.resolve(HERE, '..');
@@ -149,6 +150,21 @@ const suites = [
     args: ['--test', 'test/feature-flags.test.mjs'],
     parse: parseNodeTest,
   },
+  {
+    label: `${VERSION} shared-brain activity stream (node --test)`,
+    args: ['--test', 'test/activity-stream.test.mjs', 'test/activity-realtime.test.mjs'],
+    parse: parseNodeTest,
+  },
+  {
+    label: 'P2 state truth: focus/running/status/turn-state/open-card (node --test)',
+    args: ['--test', 'test/state-truth.test.mjs'],
+    parse: parseNodeTest,
+  },
+  {
+    label: `${VERSION} version consistency (node --test)`,
+    args: ['--test', 'test/version-consistency.test.mjs'],
+    parse: parseNodeTest,
+  },
   {
     label: 'host Config schema (node --test)',
     args: ['--test', 'test/config-schema.test.mjs'],

package/test/safety-defaults.test.mjs

@@ -137,7 +137,7 @@ test('settings client: slot key is @jjh32456/dsh-longlive#session-longlive (row
     'client 仍残留未 scoped 的模块 id');
 });
 
-test('Config schema: 85 nodes (1.6.4 adds hotTruncate), safety defaults visible, descriptions in zh+en', { skip: !CONFIG_SCHEMA_AVAILABLE }, () => {
+test('Config schema: 90 nodes (1.6.4 hotTruncate + sharedBrain.activity), safety defaults visible, descriptions in zh+en', { skip: !CONFIG_SCHEMA_AVAILABLE }, () => {
   function countNodes(schema) {
     const dict = schema?.dict;
     if (!dict || typeof dict !== 'object') return 1;
@@ -147,12 +147,14 @@ test('Config schema: 85 nodes (1.6.4 adds hotTruncate), safety defaults visible,
   }
   // The schema object itself is the root, not a field: subtract it so the count
   // matches the configured nodes. 1.6.0 had 80; 1.6.4 adds the hotTruncate
-  // block (1 parent + 4 leaves), so the budget is 85.
-  assert.equal(countNodes(Config) - 1, 85, 'Config schema 节点数必须保持 85');
+  // block (1 parent + 4 leaves) = 85; the rebased activity stream adds
+  // sharedBrain.activity (1 parent + 1 activity + 3 leaves) = 90.
+  assert.equal(countNodes(Config) - 1, 90, 'Config schema 节点数必须保持 90');
 
   const parsed = Config({});
   assert.equal(parsed.autoTruncate.enabled, false);
   assert.equal(parsed.autoTruncate.mode, 'dryrun');
+  assert.equal(parsed.sharedBrain.activity.enabled, false, 'activity stream is off by default');
   assert.match(Config.dict.autoTruncate.dict.enabled.meta.description.zh, /默认关闭/);
   assert.match(Config.dict.routerRuntime.meta.description.en, /default off/);
   assert.equal(Config.dict.memoryRoot.meta.disabled, true);