@jjh32456/dsh-longlive 1.6.8 → 1.8.0

package/test/router-1100/apply-off.test.mjs

@@ -1,175 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import test from 'node:test';
-
-import { apply } from '../../src/index.js';
-import { MockLlm } from '../../src/router/background/mock-llm.mjs';
-import { tempRoot } from './helpers.mjs';
-
-function fakeContext({ llm = null } = {}) {
-  const tools = [];
-  const effects = [];
-  const hooks = [];
-  const warnings = [];
-  const ctx = {
-    tools: {
-      register(definition) {
-        tools.push(definition);
-        return () => {};
-      },
-    },
-    on(name, listener) {
-      hooks.push({ name, listener });
-      return () => {};
-    },
-    logger() {
-      return { warn: (message) => warnings.push(String(message)), info: () => {} };
-    },
-    effect(fn) {
-      const dispose = fn();
-      effects.push(typeof dispose === 'function' ? dispose : () => {});
-      return effects[effects.length - 1];
-    },
-    get(name) {
-      return name === 'llm' ? llm : undefined;
-    },
-  };
-  return { ctx, tools, effects, hooks, warnings };
-}
-
-function memoryTree(root) {
-  const out = [];
-  const walk = (dir, rel = '') => {
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
-      const child = path.join(dir, entry.name);
-      const childRel = rel ? `${rel}/${entry.name}` : entry.name;
-      out.push(entry.isDirectory() ? `${childRel}/` : childRel);
-      if (entry.isDirectory()) walk(child, childRel);
-    }
-  };
-  if (fs.existsSync(root)) walk(root);
-  return out;
-}
-
-test('routerEnabled=false is the 0.9.0 surface: 22 tools, no router_* hooks, no .longlive', async () => {
-  const temp = tempRoot('longlive-router-off-');
-  const home = path.join(temp, 'home');
-  const memoryRoot = path.join(temp, 'memory');
-  fs.mkdirSync(memoryRoot, { recursive: true });
-  fs.writeFileSync(path.join(memoryRoot, 'STATE.md'), '## 我在哪\n测试\n', 'utf8');
-  const before = memoryTree(memoryRoot);
-  const harness = fakeContext();
-  try {
-    const returned = await apply(harness.ctx, {
-      home,
-      memoryRoot,
-      env: {},
-      heartbeatMs: 0,
-      recoverOnStart: false,
-      defineTool: (definition) => definition,
-      routerRuntime: 'off',
-    });
-    assert.equal(typeof returned, 'number');
-    assert.equal(harness.tools.length, 22);
-    assert.equal(harness.tools.some((tool) => String(tool.name).startsWith('router_')), false);
-    assert.deepEqual(memoryTree(memoryRoot), before);
-    assert.equal(fs.existsSync(path.join(memoryRoot, '.longlive')), false);
-  } finally {
-    for (const dispose of harness.effects.reverse()) dispose();
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-});
-
-test('routerEnabled=true wires the service and registers exactly the four router tools', async () => {
-  const temp = tempRoot('longlive-router-on-');
-  const home = path.join(temp, 'home');
-  const memoryRoot = path.join(temp, 'memory');
-  fs.mkdirSync(memoryRoot, { recursive: true });
-  fs.writeFileSync(path.join(memoryRoot, 'STATE.md'), '## 我在哪\n测试\n', 'utf8');
-  const llm = new MockLlm({ usage: { inputTokens: 10, outputTokens: 5 } });
-  const harness = fakeContext({ llm });
-  try {
-    const returned = await apply(harness.ctx, {
-      home,
-      memoryRoot,
-      env: {},
-      heartbeatMs: 0,
-      recoverOnStart: false,
-      defineTool: (definition) => definition,
-      routerRuntime: 'off',
-      routerEnabled: true,
-      routerProvider: 'mock',
-      routerModel: 'mock-1',
-      routerTickMs: 60000,
-    });
-    assert.equal(returned, 26);
-    const names = harness.tools.map((tool) => tool.name);
-    for (const name of ['router_status', 'router_tick', 'router_ask', 'router_report']) {
-      assert.ok(names.includes(name), `${name} must be registered`);
-    }
-    assert.equal(harness.tools.length, 26);
-
-    const statusTool = harness.tools.find((tool) => tool.name === 'router_status');
-    let status = null;
-    for (let attempt = 0; attempt < 80; attempt += 1) {
-      status = await statusTool.execute({}, {});
-      if (status?.state === 'running' || status?.state === 'blocked') break;
-      await new Promise((resolve) => setTimeout(resolve, 25));
-    }
-    assert.equal(status.ok, true);
-    assert.equal(status.state, 'running');
-    assert.ok(fs.existsSync(path.join(memoryRoot, '.longlive', 'router', 'status.json')));
-  } finally {
-    for (const dispose of harness.effects.reverse()) {
-      try { await dispose(); } catch { /* best effort */ }
-    }
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-});
-
-test('routerProposalEnabled=true adds the three proposal tools: 29', async () => {
-  const temp = tempRoot('longlive-router-proposals-');
-  const home = path.join(temp, 'home');
-  const memoryRoot = path.join(temp, 'memory');
-  fs.mkdirSync(memoryRoot, { recursive: true });
-  fs.writeFileSync(path.join(memoryRoot, 'STATE.md'), '## 我在哪\n测试\n', 'utf8');
-  const llm = new MockLlm({ usage: { inputTokens: 10, outputTokens: 5 } });
-  const harness = fakeContext({ llm });
-  try {
-    const returned = await apply(harness.ctx, {
-      home,
-      memoryRoot,
-      env: {},
-      heartbeatMs: 0,
-      recoverOnStart: false,
-      defineTool: (definition) => definition,
-      routerRuntime: 'off',
-      routerEnabled: true,
-      routerProvider: 'mock',
-      routerModel: 'mock-1',
-      routerTickMs: 60000,
-      routerProposalEnabled: true,
-    });
-    assert.equal(returned, 29);
-    const names = harness.tools.map((tool) => tool.name);
-    assert.deepEqual(
-      names.filter((name) => name.startsWith('router_')).sort(),
-      [
-        'router_apply',
-        'router_ask',
-        'router_proposals',
-        'router_propose',
-        'router_report',
-        'router_status',
-        'router_tick',
-      ],
-    );
-  } finally {
-    for (const dispose of harness.effects.reverse()) {
-      try { await dispose(); } catch { /* best effort */ }
-    }
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-});
-

package/test/router-1100/budget-reconcile.test.mjs

@@ -1,215 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import test from 'node:test';
-
-import { AuditLog } from '../../src/router/background/audit.mjs';
-import { BudgetLedger } from '../../src/router/background/budget-ledger.mjs';
-import { makeService, startedService, taskInput } from './helpers.mjs';
-
-function auditRecords(vaultDir) {
-  return fs.readFileSync(path.join(vaultDir, 'audit.jsonl'), 'utf8').trim().split('\n').map((line) => JSON.parse(line));
-}
-
-function seedOldRun(vaultDir, { used = 0, runId = 'old-run', auditSettle = null } = {}) {
-  const runDir = path.join(vaultDir, 'runs', runId);
-  fs.mkdirSync(runDir, { recursive: true });
-  const ledgerFile = path.join(runDir, 'budget.ledger.jsonl');
-  if (used > 0) {
-    const ledger = new BudgetLedger({ file: ledgerFile, runId, maxTokens: 50000 });
-    const reserved = ledger.reserve({ taskId: `${runId}-task`, tokens: used, owner: runId, tick: 1 });
-    assert.equal(reserved.ok, true);
-    const settled = ledger.settle({ id: reserved.id, tokens: used });
-    assert.equal(settled.ok, true);
-  } else {
-    fs.writeFileSync(ledgerFile, '');
-  }
-  if (auditSettle !== null) {
-    const audit = new AuditLog({ file: path.join(vaultDir, 'audit.jsonl'), runId });
-    audit.open();
-    audit.append('router.start', { run_id: runId });
-    audit.append('budget.settle', { run_id: runId, task_id: `${runId}-task`, tokens: auditSettle });
-    audit.append('router.stop', { run_id: runId });
-    audit.close();
-  }
-  return runDir;
-}
-
-test('a normal tick reserves and settles the actual usage, never the reservation', async () => {
-  const env = await startedService();
-  try {
-    env.service.queue.writer.append(taskInput('settle-1'));
-    const result = await env.service.tick({ tier: 'reflect', reason: 'test' });
-    assert.equal(result.ok, true);
-    assert.equal(result.processed, 1);
-    const records = auditRecords(env.vaultDir);
-    const reserve = records.find((record) => record.kind === 'budget.reserve' && record.task_id === 'settle-1');
-    const settle = records.find((record) => record.kind === 'budget.settle' && record.task_id === 'settle-1');
-    assert.ok(reserve);
-    assert.ok(settle);
-    assert.ok(reserve.tokens > 150, `reservation ${reserve.tokens} should exceed actual usage`);
-    assert.equal(settle.tokens, 150);
-    assert.equal(settle.usage_estimated, false);
-    assert.equal(env.service.status().run.usedTokens, 150);
-    const ledgerLines = fs.readFileSync(path.join(env.vaultDir, 'runs', env.service.runId, 'budget.ledger.jsonl'), 'utf8').trim().split('\n').map(JSON.parse);
-    assert.deepEqual(ledgerLines.map((line) => line.op), ['reserve', 'settle']);
-    assert.equal(ledgerLines[1].tokens, 150);
-  } finally {
-    await env.service.dispose();
-    env.cleanup();
-  }
-});
-
-test('budget exhaustion blocks, leaves the task queued, and never calls the model', async () => {
-  const env = await startedService({ config: { maxTokensPerRun: 5000 } });
-  try {
-    // 4900 leaves 100: even the reflect reservation (>= ~200) cannot fit, so no degrade.
-    const adopted = env.service.ledger.adopt({ used: 4900, reason: 'test preuse' });
-    assert.equal(adopted.ok, true);
-    env.service.queue.writer.append(taskInput('no-budget'));
-    const result = await env.service.tick({ tier: 'full', reason: 'test' });
-    assert.equal(result.ok, true);
-    assert.equal(env.service.status().state, 'blocked');
-    assert.equal(env.service.status().lastError.code, 'E_BUDGET_EXHAUSTED');
-    assert.equal(env.llm.calls, 0);
-    const pending = env.service.queue.pending(env.service.seen);
-    assert.equal(pending.tasks.length, 1);
-    assert.equal(pending.tasks[0].id, 'no-budget');
-    const kinds = auditRecords(env.vaultDir).map((record) => record.kind);
-    assert.ok(kinds.includes('budget.exceeded'));
-  } finally {
-    await env.service.dispose();
-    env.cleanup();
-  }
-});
-
-test('full does not fit but reflect does: degrade, audit it, and make one reflect call', async () => {
-  const env = await startedService({ config: { maxTokensPerRun: 5000 } });
-  try {
-    const adopted = env.service.ledger.adopt({ used: 3300, reason: 'test preuse' });
-    assert.equal(adopted.ok, true);
-    env.service.queue.writer.append(taskInput('degrade-1', { payload: { question: '问'.repeat(2000) } }));
-    const result = await env.service.tick({ tier: 'full', reason: 'test' });
-    assert.equal(result.ok, true);
-    assert.equal(env.llm.calls, 1);
-    const records = auditRecords(env.vaultDir);
-    const degrade = records.find((record) => record.kind === 'budget.degrade');
-    assert.ok(degrade, 'degrade must be audited');
-    assert.equal(degrade.from, 'full');
-    assert.equal(degrade.to, 'reflect');
-    assert.equal(degrade.reason, 'reserve_not_fit');
-    assert.equal(env.service.status().state, 'running');
-  } finally {
-    await env.service.dispose();
-    env.cleanup();
-  }
-});
-
-test('daily cap across an older run blocks a new tick without a second call', async () => {
-  const temp = fs.mkdtempSync(path.join(requireTmp(), 'longlive-router-day-'));
-  const memoryRoot = path.join(temp, 'memory');
-  const vaultDir = path.join(temp, 'vault');
-  fs.mkdirSync(vaultDir, { recursive: true });
-  const env = makeService({ temp, memoryRoot, vaultDir, memory: false, config: { allowMissingAnchor: true, maxTokensPerDay: 5000 } });
-  try {
-    seedOldRun(vaultDir, { used: 4900, runId: 'yesterday-run' });
-    const started = await env.service.start();
-    assert.equal(started.state, 'running');
-    env.service.queue.writer.append(taskInput('day-cap'));
-    const result = await env.service.tick({ tier: 'full', reason: 'test' });
-    assert.equal(result.ok, true);
-    assert.equal(env.service.status().state, 'blocked');
-    assert.equal(env.service.status().lastError.code, 'E_BUDGET_EXHAUSTED');
-    assert.equal(env.llm.calls, 0);
-    assert.equal(env.service.status().tickQueue.pending, 1);
-  } finally {
-    await env.service.dispose();
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-});
-
-test('usage above the reservation is an overshoot: record it and stop', async () => {
-  const env = await startedService({
-    llmOptions: { usage: { inputTokens: 5000, outputTokens: 100 } },
-    config: { maxTokensPerRun: 50000 },
-  });
-  try {
-    env.service.queue.writer.append(taskInput('overshoot-1'));
-    const result = await env.service.tick({ tier: 'reflect', reason: 'test' });
-    assert.equal(result.ok, true);
-    assert.equal(env.service.status().state, 'stopped');
-    assert.equal(env.service.status().lastError.code, 'E_BUDGET_OVERSHOOT');
-    const kinds = auditRecords(env.vaultDir).map((record) => record.kind);
-    assert.ok(kinds.includes('budget.overshoot'));
-  } finally {
-    await env.service.dispose();
-    env.cleanup();
-  }
-});
-
-test('startup reconcile repairs a crash window from the ledger side and audits it', async () => {
-  const temp = fs.mkdtempSync(path.join(requireTmp(), 'longlive-router-reconcile-'));
-  const memoryRoot = path.join(temp, 'memory');
-  const vaultDir = path.join(temp, 'vault');
-  fs.mkdirSync(vaultDir, { recursive: true });
-  const env = makeService({
-    temp,
-    memoryRoot,
-    vaultDir,
-    memory: false,
-    config: { allowMissingAnchor: true },
-  });
-  try {
-    seedOldRun(vaultDir, { used: 120, runId: 'crashed-run' });
-    const started = await env.service.start();
-    assert.equal(started.state, 'running');
-    const reconcile = auditRecords(vaultDir).find((record) => record.kind === 'audit.reconcile');
-    assert.ok(reconcile, 'audit.reconcile must be written');
-    assert.equal(reconcile.run_id, 'crashed-run');
-    assert.equal(reconcile.delta, 120);
-  } finally {
-    await env.service.dispose();
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-});
-
-test('audit settles more than the ledger: fail closed as E_LEDGER_TAMPERED', async () => {
-  const temp = fs.mkdtempSync(path.join(requireTmp(), 'longlive-router-tamper-'));
-  const memoryRoot = path.join(temp, 'memory');
-  const vaultDir = path.join(temp, 'vault');
-  fs.mkdirSync(vaultDir, { recursive: true });
-  const env = makeService({ temp, memoryRoot, vaultDir, memory: false });
-  try {
-    seedOldRun(vaultDir, { used: 0, runId: 'ghost-run', auditSettle: 100 });
-    const started = await env.service.start();
-    assert.equal(started.state, 'blocked');
-    assert.equal(started.lastError.code, 'E_LEDGER_TAMPERED');
-    const panel = env.service.status();
-    assert.ok(panel.warnings.includes('E_LEDGER_TAMPERED'));
-    assert.ok(panel.alerts.some((alert) => alert.code === 'E_LEDGER_TAMPERED'));
-  } finally {
-    await env.service.dispose();
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-});
-
-test('missing historical anchor blocks unless routerAllowMissingAnchor is true', async () => {
-  const temp = fs.mkdtempSync(path.join(requireTmp(), 'longlive-router-anchor-'));
-  const memoryRoot = path.join(temp, 'memory');
-  const vaultDir = path.join(temp, 'vault');
-  fs.mkdirSync(vaultDir, { recursive: true });
-  const env = makeService({ temp, memoryRoot, vaultDir, memory: false });
-  try {
-    seedOldRun(vaultDir, { used: 100, runId: 'anchored-run' });
-    const started = await env.service.start();
-    assert.equal(started.state, 'blocked');
-    assert.equal(started.lastError.code, 'E_ANCHOR_MISSING');
-  } finally {
-    await env.service.dispose();
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-});
-
-function requireTmp() {
-  return process.env.TEMP || process.env.TMP || '.';
-}

package/test/router-1100/config-context.test.mjs

@@ -1,211 +0,0 @@
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import test from 'node:test';
-
-import { normalizeRouterConfig, ROUTER_DEFAULTS } from '../../src/router/service/config.mjs';
-import { assembleContext, CONTEXT_TIERS } from '../../src/router/service/context.mjs';
-import { LIMITS, loadContextSources, parseIndexRows, readCappedFile } from '../../src/router/service/sources.mjs';
-import { estimateTokens, headTailTruncate, truncateToTokens } from '../../src/router/service/tokens.mjs';
-import { tempRoot, writeMemory } from './helpers.mjs';
-
-function minimalSources(overrides = {}) {
-  return {
-    stateText: '## 我在哪\n在测试。\n\n## 在等什么\n等 tick。\n\n## 最近三件\n- 一件\n',
-    handover: { name: '2026-11-04-router.md', text: '# 交接卡\n\n测试。\n' },
-    index: { rows: [{ text: '测试 | topics/test.md' }] },
-    cards: [{ name: 'test.md', text: '# 测试卡\n\n内容。' }],
-    queue: { rows: [{ id: 't1', type: 'question', depth: 0, ageMs: 1000 }] },
-    ledger: { runUsed: 10, runCap: 50000, dayUsed: 20, dayCap: 150000, reserved: 0 },
-    warnings: [],
-    now: new Date('2026-11-04T12:00:00.000Z'),
-    ...overrides,
-  };
-}
-
-test('config defaults are off and match DESIGN §8.1', () => {
-  const cfg = normalizeRouterConfig({});
-  assert.equal(cfg.enabled, false);
-  assert.equal(cfg.provider, 'deepseek-official');
-  assert.equal(cfg.model, 'auto');
-  assert.equal(cfg.tickMs, 60000);
-  assert.equal(cfg.reflectOnTurn, true);
-  assert.equal(cfg.reflectCoalesceMs, 300000);
-  assert.equal(cfg.autonomy, 'report');
-  assert.equal(cfg.allowAgent, false);
-  assert.equal(cfg.maxTokensPerRun, 80000);
-  assert.equal(cfg.maxTokensPerDay, 1000000);
-  assert.equal(cfg.callMaxTokens, 2048);
-  assert.equal(cfg.maxAttempts, 2);
-  assert.equal(cfg.maxConsecutiveErrors, 3);
-  assert.equal(cfg.injectMaxPerSessionPerDay, 24);
-  assert.equal(cfg.injectMaxTotalTokens, 12000);
-  assert.equal(cfg.l4MergeEnabled, false);
-  assert.equal(cfg.writerLeaseMs, 120000);
-  assert.equal(cfg.queueMaxBytes, 65536);
-  assert.equal(cfg.proposalEnabled, false);
-  assert.equal(cfg.wakeEnabled, false);
-  assert.equal(cfg.disposeTimeoutMs, 2000);
-  assert.equal(Object.keys(ROUTER_DEFAULTS).length, 50);
-  assert.deepEqual(cfg.warnings, []);
-  assert.equal(ROUTER_DEFAULTS.enabled, false);
-});
-
-test('config only enables on literal true, and invalid values fall back with warnings', () => {
-  assert.equal(normalizeRouterConfig({ routerEnabled: 'true' }).enabled, false);
-  assert.equal(normalizeRouterConfig({ routerEnabled: 1 }).enabled, false);
-  const cfg = normalizeRouterConfig({
-    routerEnabled: true,
-    routerTickMs: 1,
-    routerMaxAttempts: 9,
-    routerAutonomy: 'everything',
-    routerMaxQueue: 'lots',
-    routerProvider: '  mock  ',
-    unknownKey: 'ignored',
-  });
-  assert.equal(cfg.enabled, true);
-  assert.equal(cfg.tickMs, 60000);
-  assert.equal(cfg.maxAttempts, 2);
-  assert.equal(cfg.autonomy, 'report');
-  assert.equal(cfg.maxQueue, undefined);
-  assert.equal(cfg.provider, 'mock');
-  assert.ok(cfg.warnings.includes('CONFIG_INVALID:tickMs'));
-  assert.ok(cfg.warnings.includes('CONFIG_INVALID:maxAttempts'));
-  assert.ok(cfg.warnings.includes('CONFIG_INVALID:autonomy'));
-  assert.ok(cfg.warnings.includes('CONFIG_DEPRECATED:routerMaxQueue'));
-});
-
-test('token estimate uses §3.6 CJK/4-chars ×1.05 and truncation respects the cap', () => {
-  assert.equal(estimateTokens(''), 0);
-  assert.equal(estimateTokens('中文'), 3);
-  assert.equal(estimateTokens('a'.repeat(4)), 2);
-  const cut = truncateToTokens('中'.repeat(100), 10);
-  assert.equal(cut.truncated, true);
-  assert.ok(estimateTokens(cut.text) <= 10, `got ${estimateTokens(cut.text)}`);
-  assert.ok(cut.text.endsWith('…'));
-  const headTail = headTailTruncate('a'.repeat(1000), 100);
-  assert.equal(headTail.truncated, true);
-  assert.match(headTail.text, /…\[truncated \d+ chars\]…/);
-});
-
-test('full assembly stays inside 11,000 including reserves and keeps all parts', () => {
-  const result = assembleContext({ tier: 'full', task: { id: 't1', type: 'question', payload: { question: 'hi' } }, sources: minimalSources() });
-  assert.equal(result.ok, true);
-  assert.equal(result.tier, 'full');
-  assert.ok(result.totalTokens <= CONTEXT_TIERS.full.budget);
-  assert.equal(result.outputReserve, 1000);
-  assert.equal(result.safety, 1000);
-  assert.ok(result.parts.system.includes('后台路由器'));
-  assert.ok(result.parts.openCard.includes('▍我在哪'));
-  assert.match(result.messages.prompt, /【队列】/);
-  assert.match(result.messages.prompt, /【预算】/);
-});
-
-test('reflect assembly excludes INDEX and topic cards and stays inside 2,000', () => {
-  const result = assembleContext({ tier: 'reflect', task: { id: 't1', type: 'question', payload: { question: 'hi' } }, sources: minimalSources() });
-  assert.equal(result.ok, true);
-  assert.equal(result.tier, 'reflect');
-  assert.ok(result.totalTokens <= CONTEXT_TIERS.reflect.budget);
-  assert.equal(result.parts.index, undefined);
-  assert.equal(Object.keys(result.parts).some((key) => key.startsWith('card:')), false);
-});
-
-test('trim order starts with least-relevant topic card, then queue, then task', () => {
-  const longCjk = '测'.repeat(20000);
-  const sources = minimalSources({
-    stateText: `## 我在哪\n${longCjk}\n\n## 在等什么\n等。\n\n## 最近三件\n- 一\n`,
-    cards: [
-      { name: 'a.md', text: `# A\n${'甲'.repeat(4000)}` },
-      { name: 'b.md', text: `# B\n${'乙'.repeat(4000)}` },
-    ],
-    queue: {
-      rows: Array.from({ length: 8 }, (_, i) => ({ id: `q${i}`, type: 'question', depth: 0, ageMs: 1000 * i })),
-    },
-    index: { rows: Array.from({ length: 12 }, (_, i) => ({ text: `行${i} | topics/t${i}.md` })) },
-  });
-  const result = assembleContext({
-    tier: 'full',
-    task: { id: 'big', type: 'question', payload: { question: '问'.repeat(5000) } },
-    sources,
-  });
-  assert.equal(result.ok, true);
-  assert.ok(result.dropped.length > 0);
-  assert.equal(result.dropped[0], 'card:b.md');
-  assert.ok(result.totalTokens <= 11000);
-});
-
-test('over-budget input reports E_CONTEXT_OVER_BUDGET and can degrade from full only', () => {
-  const huge = minimalSources({
-    stateText: `## 我在哪\n${'测'.repeat(50000)}\n\n## 在等什么\n等。\n\n## 最近三件\n- 一\n`,
-    cards: [
-      { name: 'a.md', text: '甲'.repeat(1200) },
-      { name: 'b.md', text: '乙'.repeat(1200) },
-    ],
-  });
-  const full = assembleContext({ tier: 'full', task: { id: 't', payload: { question: '问'.repeat(100000) } }, sources: huge });
-  // Huge cards/queue/index are trimmed; if it still does not fit the contract is
-  // a fail-closed E_CONTEXT_OVER_BUDGET with canDegrade=true, never a forced fit.
-  if (full.ok) {
-    assert.ok(full.totalTokens <= 11000);
-  } else {
-    assert.equal(full.code, 'E_CONTEXT_OVER_BUDGET');
-    assert.equal(full.canDegrade, true);
-    assert.equal(full.degradeTo, 'reflect');
-    assert.ok(full.dropped.length > 0);
-  }
-});
-
-test('parseIndexRows reads the first markdown table and trims cells to 80 chars', () => {
-  const rows = parseIndexRows([
-    '# INDEX',
-    '| 主题 | 文件 |',
-    '|---|---|',
-    `| ${'长'.repeat(120)} | topics/a.md |`,
-    '| 第二 | topics/b.md |',
-  ].join('\n'));
-  assert.equal(rows.length, 2);
-  assert.equal(Array.from(rows[0].text).length, 80);
-  assert.equal(rows[1].cells[1], 'topics/b.md');
-});
-
-test('readCappedFile never reads more than maxBytes and reports truncation', async () => {
-  const temp = tempRoot();
-  try {
-    const file = path.join(temp, 'big.txt');
-    fs.writeFileSync(file, 'a'.repeat(100000));
-    const read = await readCappedFile(file, { maxBytes: 1024, stability: false });
-    assert.equal(read.ok, true);
-    assert.equal(read.truncated, true);
-    assert.equal(Buffer.byteLength(read.text, 'utf8'), 1024);
-    assert.equal(read.bytes, 100000);
-  } finally {
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-});
-
-test('loadContextSources reads only STATE/handover/INDEX/topics and never journal or flow', async () => {
-  const temp = tempRoot();
-  try {
-    const memoryRoot = path.join(temp, 'memory');
-    writeMemory(memoryRoot);
-    fs.mkdirSync(path.join(memoryRoot, 'journal'), { recursive: true });
-    fs.writeFileSync(path.join(memoryRoot, 'journal', '2026-11.md'), '# journal\nSHOULD NOT BE READ\n');
-    fs.mkdirSync(path.join(memoryRoot, 'flow'), { recursive: true });
-    fs.writeFileSync(path.join(memoryRoot, 'flow', 'current.md'), '# flow\nSHOULD NOT BE READ\n');
-    const sources = await loadContextSources({
-      memoryRoot,
-      task: { type: 'question', payload: { question: '测试' } },
-      now: new Date('2026-11-04T12:00:00.000Z'),
-      stability: { enabled: false },
-    });
-    assert.equal(sources.stateFound, true);
-    assert.ok(Array.isArray(sources.cards));
-    assert.equal(sources.cards.length <= LIMITS.cardsKeep, true);
-    const serialized = JSON.stringify(sources);
-    assert.equal(serialized.includes('SHOULD NOT BE READ'), false);
-    assert.equal(serialized.includes('journal'), false);
-    assert.equal(serialized.includes('flow/current'), false);
-  } finally {
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-});