@jjh32456/dsh-longlive 1.6.7 → 1.8.0

package/test/cli-guard.test.mjs

@@ -1,198 +0,0 @@
-// @local/dsh-longlive — the CLI's own "is this session still running?" gate
-//
-// scripts/truncate-cli.mjs is spawned by the orchestrator after the app was
-// supposed to exit. It has no tool context, so it must answer the live-target
-// question itself. These cases pin that contract:
-//   * the CLI source does not import the tool layer (the gate cannot be the
-//     tool's guard reached through a second door);
-//   * a fresh live-registry row refuses with SESSION_IS_RUNNING and leaves
-//     every byte alone;
-//   * an inherited $DSH_SESSION_ID naming the target refuses the same way;
-//   * the exclusive-handle probe is wired in (held -> running);
-//   * with no live signal the CLI cuts normally.
-//
-// Fixtures are synthetic logs under TMP; nothing here reads ~/.dsh/sessions.
-
-import fs from 'node:fs';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import { spawnSync } from 'node:child_process';
-import { fileURLToPath } from 'node:url';
-
-import { writeFixture } from './truncate-visible.test.mjs';
-import { detectLiveTarget, LIVE_TARGET_CODES, sessionIdOfLogFile } from '../src/live-target.js';
-import { liveUpdate } from '../src/live.js';
-import { ERROR_CODES } from '../src/truncate.js';
-
-const HERE = path.dirname(fileURLToPath(import.meta.url));
-const ROOT = path.resolve(HERE, '..');
-const CLI = path.join(ROOT, 'scripts', 'truncate-cli.mjs');
-
-function sha256(file) {
-  return crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');
-}
-
-function runCli(args, envOverrides = {}) {
-  const env = { ...process.env, ...envOverrides };
-  for (const [key, value] of Object.entries(envOverrides)) {
-    if (value === undefined) delete env[key];
-  }
-  const run = spawnSync(process.execPath, [CLI, ...args], {
-    cwd: ROOT,
-    env,
-    encoding: 'utf8',
-    timeout: 120_000,
-  });
-  const lines = String(run.stdout ?? '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-  const jsonLine = [...lines].reverse().find((line) => line.startsWith('{')) ?? null;
-  let json = null;
-  if (jsonLine) {
-    try { json = JSON.parse(jsonLine); } catch { json = null; }
-  }
-  return {
-    status: run.status,
-    json,
-    stdout: String(run.stdout ?? ''),
-    stderr: String(run.stderr ?? ''),
-  };
-}
-
-function visibleArgs(sessionPath, memoryRoot) {
-  return [
-    '--session', sessionPath,
-    '--keep-turns', '5',
-    '--keep-tokens', '1000000',
-    '--confirm', 'TRUNCATE-VISIBLE',
-    '--memory-root', memoryRoot,
-  ];
-}
-
-export function runCliGuardSuite({ runCase, assert, TMP }) {
-  const base = path.join(TMP, 'cli-guard');
-  fs.mkdirSync(base, { recursive: true });
-  // rc.2: truncate-cli.mjs only writes under <DSH_HOME>/sessions; fixtures
-  // already live at <base>/home/sessions, so point the child at that home.
-  const cli = (args, extra = {}) => runCli(args, { DSH_HOME: path.join(base, 'home'), ...extra });
-
-  runCase('CLI1', 'truncate-cli 不 import 工具层，活体判定由 detectLiveTarget 自己完成', () => {
-    const source = fs.readFileSync(CLI, 'utf8');
-    assert(!/src[\\/]tools\.js/.test(source), 'CLI source still references src/tools.js');
-    assert(source.includes('detectLiveTarget'), 'CLI does not call detectLiveTarget');
-    assert(source.includes('SESSION_IS_RUNNING'), 'CLI does not name the refusal code');
-    assert(source.includes('--memory-root'), 'CLI cannot receive the memory root');
-    return 'CLI self-checks via live-target.js only';
-  });
-
-  runCase('CLI2', 'detectLiveTarget：注册表/独占句柄/$DSH_SESSION_ID 任一命中即 running', () => {
-    const { file } = writeFixture(base, 'guard-unit');
-    const targetId = sessionIdOfLogFile(file).id;
-
-    const held = detectLiveTarget(file, {
-      env: {},
-      probe: () => {
-        const error = new Error('held by the app');
-        error.code = ERROR_CODES.FILE_BUSY;
-        throw error;
-      },
-    });
-    assert(held.running === true && held.code === LIVE_TARGET_CODES.SESSION_IS_RUNNING,
-      `held handle -> running=${held.running} code=${held.code}`);
-    assert(held.reasons.some((item) => item.signal === 'exclusive-handle'),
-      'held handle produced no exclusive-handle reason');
-
-    const free = detectLiveTarget(file, { env: {}, probe: () => {} });
-    assert(free.running === false, `free handle -> running=${free.running}`);
-    assert(free.checks.some((item) => item.name === 'exclusive-handle' && item.status === 'free'),
-      'free handle was not recorded');
-
-    const envHit = detectLiveTarget(file, {
-      env: { DSH_SESSION_ID: targetId.toUpperCase() },
-      probe: () => {},
-    });
-    assert(envHit.running === true, 'inherited $DSH_SESSION_ID was not treated as running');
-    assert(envHit.reasons.some((item) => item.signal === 'env-session-id'),
-      'env hit produced no env-session-id reason');
-    assert(envHit.code === LIVE_TARGET_CODES.SESSION_IS_RUNNING, `env hit code ${envHit.code}`);
-
-    const memRoot = path.join(base, 'unit-memory');
-    fs.mkdirSync(memRoot, { recursive: true });
-    liveUpdate({ sessionId: targetId, state: 'running' }, { memoryRoot: memRoot });
-    const registryHit = detectLiveTarget(file, { memoryRoot: memRoot, env: {}, probe: () => {} });
-    assert(registryHit.running === true, 'fresh live-registry row was not treated as running');
-    assert(registryHit.reasons.some((item) => item.signal === 'live-registry'),
-      'registry hit produced no live-registry reason');
-    return 'all three signals refuse';
-  });
-
-  runCase('CLI3', 'CLI 在写前看到 running 注册表行：exit 2 + SESSION_IS_RUNNING，字节不变', () => {
-    const { file } = writeFixture(base, 'guard-registry');
-    const targetId = sessionIdOfLogFile(file).id;
-    const memRoot = path.join(base, 'registry-memory');
-    fs.mkdirSync(memRoot, { recursive: true });
-    liveUpdate({ sessionId: targetId, state: 'running' }, { memoryRoot: memRoot });
-
-    const before = sha256(file);
-    const beforeFiles = fs.readdirSync(path.dirname(file)).sort();
-    const result = cli(visibleArgs(file, memRoot), { DSH_SESSION_ID: undefined });
-    assert(result.status === 2, `exit ${result.status} (stderr ${result.stderr.slice(0, 200)})`);
-    assert(result.json && result.json.ok === false, 'refusal emitted no ok:false JSON');
-    assert(result.json.code === LIVE_TARGET_CODES.SESSION_IS_RUNNING,
-      `refusal code ${result.json && result.json.code}`);
-    assert(sha256(file) === before, 'refused CLI run changed the session bytes');
-    assert(fs.readdirSync(path.dirname(file)).sort().join('|') === beforeFiles.join('|'),
-      'refused CLI run created files beside the session');
-    return 'registry row blocks the write';
-  });
-
-  runCase('CLI4', 'CLI 继承 $DSH_SESSION_ID 指向目标会话：exit 2 + SESSION_IS_RUNNING', () => {
-    const { file } = writeFixture(base, 'guard-env');
-    const targetId = sessionIdOfLogFile(file).id;
-    const memRoot = path.join(base, 'env-memory');
-    fs.mkdirSync(memRoot, { recursive: true });
-
-    const before = sha256(file);
-    const result = cli(visibleArgs(file, memRoot), { DSH_SESSION_ID: targetId });
-    assert(result.status === 2, `exit ${result.status}`);
-    assert(result.json && result.json.code === LIVE_TARGET_CODES.SESSION_IS_RUNNING,
-      `refusal code ${result.json && result.json.code}`);
-    const reasons = Array.isArray(result.json.reasons) ? result.json.reasons : [];
-    assert(reasons.some((item) => item.signal === 'env-session-id'),
-      'refusal did not name the env-session-id signal');
-    assert(sha256(file) === before, 'refused CLI run changed the session bytes');
-    return 'inherited session id blocks the write';
-  });
-
-  runCase('CLI6', 'CLI 拒绝 sessions 根外的 --session：exit 2 + E_SESSION_PATH_OUTSIDE，字节不变', () => {
-    const outsideDir = path.join(base, 'outside');
-    fs.mkdirSync(outsideDir, { recursive: true });
-    const outside = path.join(outsideDir, 'session.v4.jsonl.zstd');
-    fs.copyFileSync(writeFixture(base, 'guard-outside-src').file, outside);
-    const before = sha256(outside);
-    const result = cli(visibleArgs(outside, path.join(base, 'outside-memory')), { DSH_SESSION_ID: undefined });
-    assert(result.status === 2, `exit ${result.status} code=${result.json && result.json.code}`);
-    assert(result.json && result.json.ok === false, 'outside path emitted no ok:false JSON');
-    assert(result.json.code === 'E_SESSION_PATH_OUTSIDE', `outside code ${result.json && result.json.code}`);
-    assert(sha256(outside) === before, 'refused outside path changed the file');
-    assert(!fs.existsSync(path.join(outsideDir, 'session.v4.jsonl.zstd.bak'))
-      && !fs.existsSync(path.join(outsideDir, 'session.v4.jsonl.zstd.archive')),
-      'refused outside path created side files');
-    return 'containment refusal keeps a concrete code';
-  });
-
-  runCase('CLI5', 'CLI 无任何活体信号：正常截断（exit 0，ok true，字节改变）', () => {
-    const { file } = writeFixture(base, 'guard-control');
-    const memRoot = path.join(base, 'control-memory');
-    fs.mkdirSync(memRoot, { recursive: true });
-
-    const before = sha256(file);
-    const result = cli(visibleArgs(file, memRoot), { DSH_SESSION_ID: undefined });
-    assert(result.status === 0,
-      `exit ${result.status} code=${result.json && result.json.code} stdout=${result.stdout.slice(0, 300)}`);
-    assert(result.json && result.json.ok === true, 'control run did not report ok:true');
-    assert(result.json.status === 'truncated', `control run status ${result.json && result.json.status}`);
-    assert(sha256(file) !== before, 'control run did not change the session bytes');
-    return `control cut ok (${result.json.bytes.before} -> ${result.json.bytes.after} bytes)`;
-  });
-}
-
-export const CLI_GUARD_CASES = ['CLI1', 'CLI2', 'CLI3', 'CLI4', 'CLI5', 'CLI6'];

package/test/conclusion.test.mjs

@@ -1,408 +0,0 @@
-// A1 (conclusion write-back) + A2 (shared-board lastConclusion) tests.
-//
-// Everything writes under the runner's TMP directory only: the P6 gate in
-// test/run.mjs fails the suite if the package tree changes during a run.
-
-import fs from 'node:fs';
-import path from 'node:path';
-
-import {
-  bridgeMarkerFile,
-  classifyConclusionText,
-  conclusionCardFile,
-  createConclusionBridge,
-  judgeConclusion,
-  readBridgeMarker,
-} from '../src/conclusion.js';
-import {
-  LAST_CONCLUSION_MAX,
-  boardHashOf,
-  createBoardBuilder,
-  lastConclusionOf,
-  readBridgeConclusions,
-} from '../src/router/service/board.mjs';
-import { renderHint } from '../src/router/service/hint.mjs';
-import { liveUpdate } from '../src/live.js';
-
-const NOW_MS = Date.parse('2026-11-05T12:00:00.000Z');
-const NOW = new Date(NOW_MS);
-
-// test/run.mjs passes a plain assert(cond, message) function; keep a small
-// object-shaped adapter so the cases below read naturally.
-function makeAssert(check) {
-  const api = (cond, message) => check(cond, message);
-  api.ok = (value, message) => check(value, message || `expected truthy, got ${String(value)}`);
-  api.equal = (actual, expected, message) => {
-    check(actual === expected, message || `expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
-  };
-  api.notEqual = (actual, expected, message) => {
-    check(actual !== expected, message || `did not expect ${JSON.stringify(expected)}`);
-  };
-  api.deepEqual = (actual, expected, message) => {
-    check(JSON.stringify(actual) === JSON.stringify(expected),
-      message || `expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
-  };
-  return api;
-}
-
-function userEvent(text, extra = {}) {
-  return {
-    type: 'user/message',
-    data: {
-      content: [{ type: 'text', text }],
-      source: { kind: 'user', clientTimeZone: 'Asia/Shanghai' },
-      role: 'user',
-      id: `u-${Math.random().toString(16).slice(2)}`,
-      ...extra,
-    },
-  };
-}
-
-function injectedUserEvent(text) {
-  return {
-    type: 'user/message',
-    data: {
-      content: [{ type: 'text', text }],
-      source: { kind: 'user' },
-      role: 'user',
-      id: 'u-injected',
-    },
-  };
-}
-
-function assistantEvent(turn, blocks) {
-  return {
-    type: 'assistant/message',
-    data: {
-      turn,
-      step: 1,
-      message: {
-        role: 'assistant',
-        content: blocks,
-        source: { kind: 'model' },
-        id: `a-${turn}`,
-      },
-    },
-  };
-}
-
-function turnStart(turn) {
-  return { type: 'turn/start', data: { turn } };
-}
-
-function turnEnd(turn, kind = 'completed') {
-  return { type: 'turn/end', data: { turn, reason: { kind } } };
-}
-
-function writeJson(file, value) {
-  fs.mkdirSync(path.dirname(file), { recursive: true });
-  fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
-}
-
-export function runConclusionSuite({ runCase, assert: rawAssert, TMP }) {
-  const assert = makeAssert(rawAssert);
-
-  const fixture = (name) => {
-    const root = path.join(TMP, `conclusion-${name}`);
-    fs.mkdirSync(root, { recursive: true });
-    return root;
-  };
-
-  const session = { id: 'session-alpha' };
-
-  function feedThreeTurns(bridge) {
-    bridge.onSessionEvent(session, turnStart(1));
-    bridge.onSessionEvent(session, userEvent('先看看现在的情况'));
-    bridge.onSessionEvent(session, assistantEvent(1, [
-      { type: 'text', text: '现在有两个方案，A 和 B，各有取舍，需要你定一个。' },
-    ]));
-    bridge.onSessionEvent(session, turnEnd(1));
-
-    bridge.onSessionEvent(session, turnStart(2));
-    bridge.onSessionEvent(session, userEvent('A 方案改起来麻烦吗'));
-    bridge.onSessionEvent(session, assistantEvent(2, [
-      { type: 'reasoning', text: 'REASONING-内部推理不该进卡' },
-      { type: 'text', text: 'A 方案改动面大一些，B 方案更稳，两种都能做。' },
-    ]));
-    bridge.onSessionEvent(session, turnEnd(2));
-
-    bridge.onSessionEvent(session, turnStart(3));
-    bridge.onSessionEvent(session, userEvent('改成用 A 方案吧'));
-    bridge.onSessionEvent(session, assistantEvent(3, [
-      { type: 'reasoning', text: 'REASONING-最终轮推理' },
-      { type: 'text', text: '好，按这个来，以后都走 A 方案生成。' },
-    ]));
-    bridge.onSessionEvent(session, turnEnd(3));
-  }
-
-  runCase('K1', 'local decision/fact rules classify without an LLM', () => {
-    assert.equal(classifyConclusionText('定了，就用 B 方案'), 'decision');
-    assert.equal(classifyConclusionText('结论是走 A 路线'), 'decision');
-    assert.equal(classifyConclusionText('结论：走 A 路线'), 'fact');
-    assert.equal(classifyConclusionText('以后都按这个来'), 'decision');
-    assert.equal(classifyConclusionText('今天天气不错'), null);
-    assert.equal(classifyConclusionText(''), null);
-    assert.equal(judgeConclusion({ userText: '改成 A', assistantText: '好。' }), null);
-    assert.equal(judgeConclusion({ userText: '随便', assistantText: '窗外的树在动。' }), null);
-    const judged = judgeConclusion({
-      userText: '改成用 A 方案',
-      assistantText: '好，按这个来，以后都走 A 方案生成。',
-    });
-    assert.equal(judged.kind, 'decision');
-    assert.ok(Array.from(judged.body).length <= 500);
-    assert.ok(Array.from(judged.title).length <= 60);
-    assert.ok(judged.body.includes('用户：'));
-    assert.ok(judged.body.includes('助手：'));
-  });
-
-  runCase('K2', 'three turns write one card; reasoning blocks never reach it', () => {
-    const root = fixture('card');
-    const bridge = createConclusionBridge({ enabled: true, memoryRoot: root, now: () => NOW });
-    feedThreeTurns(bridge);
-    const file = conclusionCardFile(root, 'session-alpha', 3);
-    assert.ok(fs.existsSync(file), 'card should exist for turn 3');
-    const text = fs.readFileSync(file, 'utf8');
-    assert.ok(text.startsWith('---\n'));
-    assert.ok(text.includes('kind: decision'));
-    assert.ok(text.includes('source_session: session-alpha'));
-    assert.ok(text.includes('source_turn: 3'));
-    assert.ok(text.includes('written_at: 2026-11-05'));
-    assert.ok(!text.includes('REASONING'));
-    assert.ok(!text.includes('今天天气'));
-    const body = text.split('\n---\n')[1] ?? '';
-    assert.ok(Array.from(body).length <= 500, `body too long: ${Array.from(body).length}`);
-    const marker = readBridgeMarker(root, 'session-alpha');
-    assert.equal(marker.lastConclusion.turn, 3);
-    assert.equal(marker.lastConclusion.kind, 'decision');
-    assert.ok(marker.lastConclusion.text.includes('按这个来'));
-    assert.ok(Array.from(marker.lastConclusion.text).length <= LAST_CONCLUSION_MAX);
-    assert.deepEqual(Object.keys(marker.turns), ['3']);
-    assert.equal(bridge.stats.written, 1);
-    assert.equal(bridge.stats.skipped, 2);
-  });
-
-  runCase('K3', 'same session + turn is idempotent (marker survives a new bridge)', () => {
-    const root = fixture('idempotent');
-    const first = createConclusionBridge({ enabled: true, memoryRoot: root, now: () => NOW });
-    feedThreeTurns(first);
-    feedThreeTurns(first);
-    assert.equal(first.stats.duplicates, 1);
-    const second = createConclusionBridge({ enabled: true, memoryRoot: root, now: () => NOW });
-    feedThreeTurns(second);
-    assert.equal(second.stats.duplicates, 1);
-    const files = fs.readdirSync(path.join(root, 'topics'));
-    assert.equal(files.filter((name) => name.startsWith('conclusion-')).length, 1);
-  });
-
-  runCase('K4', 'privacy gate blocks the card; a throwing gate fails closed', () => {
-    const root = fixture('privacy');
-    const skipped = createConclusionBridge({
-      enabled: true,
-      memoryRoot: root,
-      now: () => NOW,
-      privacyScan: () => ({ verdict: 'local_only', spans: [], reasons: ['test'] }),
-    });
-    feedThreeTurns(skipped);
-    assert.equal(skipped.stats.privacy, 1);
-    assert.equal(fs.existsSync(conclusionCardFile(root, 'session-alpha', 3)), false);
-
-    const root2 = fixture('privacy-throw');
-    const failed = createConclusionBridge({
-      enabled: true,
-      memoryRoot: root2,
-      now: () => NOW,
-      privacyScan: () => { throw new Error('gate down'); },
-    });
-    feedThreeTurns(failed);
-    assert.equal(failed.stats.privacy, 1);
-    assert.equal(fs.existsSync(conclusionCardFile(root2, 'session-alpha', 3)), false);
-  });
-
-  runCase('K5', 'non-completed turns and injected user text never write', () => {
-    const root = fixture('gates');
-    const bridge = createConclusionBridge({ enabled: true, memoryRoot: root, now: () => NOW });
-    bridge.onSessionEvent(session, turnStart(1));
-    bridge.onSessionEvent(session, injectedUserEvent('<system-reminder>注入块</system-reminder> 改成 A'));
-    bridge.onSessionEvent(session, assistantEvent(1, [{ type: 'text', text: '好，按这个来，以后都走 A 方案。' }]));
-    bridge.onSessionEvent(session, turnEnd(1, 'aborted'));
-    assert.equal(fs.existsSync(conclusionCardFile(root, 'session-alpha', 1)), false);
-    assert.equal(bridge.stats.skipped, 1);
-    // reasoning-only assistant messages leave no text to judge
-    bridge.onSessionEvent(session, turnStart(2));
-    bridge.onSessionEvent(session, userEvent('改成 A 吧'));
-    bridge.onSessionEvent(session, assistantEvent(2, [{ type: 'reasoning', text: '只是想一想' }]));
-    bridge.onSessionEvent(session, turnEnd(2));
-    assert.equal(bridge.stats.skipped, 2);
-  });
-
-  runCase('K6', 'a write failure is swallowed and never throws', () => {
-    const root = fixture('failure');
-    // Occupy the topics path with a file: mkdirSync/write must fail inside the
-    // bridge, which has to count an error instead of throwing.
-    fs.writeFileSync(path.join(root, 'topics'), 'not a directory\n', 'utf8');
-    const bridge = createConclusionBridge({ enabled: true, memoryRoot: root, now: () => NOW });
-    feedThreeTurns(bridge);
-    assert.equal(bridge.stats.written, 0);
-    assert.ok(bridge.stats.errors >= 1);
-    assert.equal(bridge.stats.privacy, 0);
-  });
-
-  runCase('K7', 'lastConclusionOf accepts only clean strings or {text}', () => {
-    assert.equal(lastConclusionOf(undefined), null);
-    assert.equal(lastConclusionOf(null), null);
-    assert.equal(lastConclusionOf(''), null);
-    assert.equal(lastConclusionOf('   '), null);
-    assert.equal(lastConclusionOf(42), null);
-    assert.equal(lastConclusionOf([]), null);
-    assert.equal(lastConclusionOf({ text: 42 }), null);
-    assert.equal(lastConclusionOf({ text: '' }), null);
-    assert.equal(lastConclusionOf('  a\n b\u0000c '), 'a b c');
-    const long = lastConclusionOf('x'.repeat(200));
-    assert.equal(Array.from(long).length, LAST_CONCLUSION_MAX);
-    assert.ok(long.endsWith('…'));
-  });
-
-  runCase('K8', 'board focus carries A1 conclusion and boardHash follows it', () => {
-    const root = fixture('board');
-    liveUpdate({
-      sessionId: 'session-alpha',
-      state: 'running',
-      goal: '写 A1',
-      last_action: { kind: 'edit', detail: '改了 board.mjs', at: NOW.toISOString() },
-    }, { memoryRoot: root, now: NOW_MS });
-    writeJson(path.join(root, '.longlive', 'bridge', 'session-alpha.json'), {
-      v: 1,
-      sessionId: 'session-alpha',
-      updatedAt: NOW.toISOString(),
-      lastConclusion: {
-        text: '好，按这个来，以后都走 A 方案生成。',
-        kind: 'decision',
-        turn: 3,
-        at: NOW.toISOString(),
-      },
-      turns: { 3: NOW.toISOString() },
-    });
-    const builder = createBoardBuilder({
-      memoryRoot: root,
-      config: {},
-      now: () => NOW,
-      paths: { bridgeDir: path.join(root, '.longlive', 'bridge') },
-    });
-    const { board } = builder.build({});
-    assert.equal(board.focus.length, 1);
-    assert.equal(board.focus[0].lastConclusion, '好，按这个来，以后都走 A 方案生成。');
-    assert.equal(readBridgeConclusions(path.join(root, '.longlive', 'bridge')).get('session-alpha'),
-      '好，按这个来，以后都走 A 方案生成。');
-    const without = { ...board, focus: [{ ...board.focus[0], lastConclusion: null }] };
-    assert.notEqual(boardHashOf(board), boardHashOf(without));
-  });
-
-  runCase('K9', 'board falls back to last_action.detail and ignores dirty markers', () => {
-    const root = fixture('board-fallback');
-    liveUpdate({
-      sessionId: 'session-beta',
-      state: 'running',
-      goal: '写 A2',
-      last_action: { kind: 'edit', detail: 'turn 结束 #7', at: NOW.toISOString() },
-    }, { memoryRoot: root, now: NOW_MS });
-    writeJson(path.join(root, '.longlive', 'bridge', 'session-beta.json'), {
-      v: 1,
-      sessionId: 'session-beta',
-      lastConclusion: { text: '   ' },
-    });
-    const builder = createBoardBuilder({ memoryRoot: root, config: {}, now: () => NOW, paths: {} });
-    const { board } = builder.build({});
-    assert.equal(board.focus[0].lastConclusion, 'turn 结束 #7');
-
-    // A row with no explicit action only carries `state=...`; that lifecycle
-    // detail must not be rendered as a conclusion.
-    liveUpdate({ sessionId: 'session-delta', state: 'running', goal: '无动作' },
-      { memoryRoot: root, now: NOW_MS });
-    const withDelta = builder.build({}).board;
-    const delta = withDelta.focus.find((item) => item.sessionId === 'session-delta');
-    assert.ok(delta, 'session-delta should be on the board');
-    assert.equal(delta.lastConclusion, null);
-
-    // Junk JSON and unknown shapes are skipped, not rendered.
-    writeJson(path.join(root, '.longlive', 'bridge', 'session-gamma.json'), {
-      v: 1,
-      sessionId: 'session-gamma',
-      lastConclusion: { text: { nested: true } },
-    });
-    fs.writeFileSync(path.join(root, '.longlive', 'bridge', 'broken.json'), '{not json', 'utf8');
-    const conclusions = readBridgeConclusions(path.join(root, '.longlive', 'bridge'));
-    assert.equal(conclusions.has('session-gamma'), false);
-    assert.equal(conclusions.has('session-beta'), false);
-  });
-
-  runCase('K10', 'hint renders 目标 / 最近 / 结论 and B sees A', () => {
-    const root = fixture('hint');
-    liveUpdate({
-      sessionId: 'session-a',
-      state: 'running',
-      goal: '写 A1 回流',
-      last_action: { kind: 'edit', detail: '改 conclusion.js', at: NOW.toISOString() },
-    }, { memoryRoot: root, now: NOW_MS });
-    writeJson(path.join(root, '.longlive', 'bridge', 'session-a.json'), {
-      v: 1,
-      sessionId: 'session-a',
-      lastConclusion: { text: '决定：结论回流先默认关，等验收后再开。', kind: 'decision', turn: 4, at: NOW.toISOString() },
-    });
-    liveUpdate({
-      sessionId: 'session-b',
-      state: 'running',
-      goal: '写 A2 看板',
-    }, { memoryRoot: root, now: NOW_MS });
-    const builder = createBoardBuilder({ memoryRoot: root, config: {}, now: () => NOW, paths: {} });
-    const { board } = builder.build({});
-    const hint = renderHint(board, { tier: 'full', now: NOW_MS, selfSessionId: 'session-b' });
-    assert.ok(hint.text.includes('目标「写 A1 回流」'));
-    assert.ok(hint.text.includes('最近：edit 改 conclusion.js'));
-    assert.ok(hint.text.includes('结论：决定：结论回流先默认关，等验收后再开。'));
-    assert.ok(!hint.text.includes('注入'), 'hint must not leak unrelated text');
-    assert.ok(hint.tokens <= 700);
-  });
-
-  runCase('K11', 'board write/read keeps lastConclusion in the persisted JSON', () => {
-    const root = fixture('persist');
-    liveUpdate({
-      sessionId: 'session-a',
-      state: 'idle',
-      goal: '收尾',
-    }, { memoryRoot: root, now: NOW_MS });
-    writeJson(path.join(root, '.longlive', 'bridge', 'session-a.json'), {
-      v: 1,
-      sessionId: 'session-a',
-      lastConclusion: { text: '就这样，A2 用 board 现有字段，不新增配置键。', kind: 'decision', turn: 9 },
-    });
-    const vault = path.join(root, '.longlive', 'router');
-    const builder = createBoardBuilder({
-      memoryRoot: root,
-      config: {},
-      now: () => NOW,
-      paths: {
-        boardFile: path.join(vault, 'board.json'),
-        rosterFile: path.join(vault, 'index', 'roster.json'),
-        proposalsDir: path.join(vault, 'proposals'),
-        bridgeDir: path.join(root, '.longlive', 'bridge'),
-      },
-    });
-    const { board } = builder.build({});
-    const written = builder.write({ board, roster: [] });
-    assert.equal(written.ok, true);
-    const persisted = JSON.parse(fs.readFileSync(path.join(vault, 'board.json'), 'utf8'));
-    assert.equal(persisted.focus[0].lastConclusion, board.focus[0].lastConclusion);
-    const readBack = builder.read();
-    assert.equal(readBack.hash, written.board.hash);
-  });
-
-  runCase('K12', 'disabled bridge is a no-op', () => {
-    const root = fixture('disabled');
-    const bridge = createConclusionBridge({ enabled: false, memoryRoot: root, now: () => NOW });
-    feedThreeTurns(bridge);
-    assert.equal(bridge.enabled, false);
-    assert.equal(bridge.stats.written, 0);
-    assert.equal(fs.existsSync(path.join(root, 'topics')), false);
-    assert.equal(fs.existsSync(bridgeMarkerFile(root, 'session-alpha')), false);
-  });
-}