@jjh32456/dsh-longlive 1.6.8 → 1.8.0

package/test/router-1100/tools-contract.test.mjs

@@ -1,164 +0,0 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-
-import { createRouterTools } from '../../src/router/service/tools.mjs';
-
-function fakeService(overrides = {}) {
-  const calls = { tick: [], ask: [], report: [] };
-  const service = {
-    config: { enabled: true },
-    runId: 'run-test',
-    panelState: 'running',
-    status: () => ({
-      v: 1,
-      state: 'running',
-      runId: 'run-test',
-      today: { day: '2026-11-04', usedTokens: 10, reservedTokens: 0, capTokens: 1000 },
-      run: { usedTokens: 10, reservedTokens: 0, capTokens: 5000 },
-      queue: { pending: 0, invalid: 0, oldestAgeMs: 0 },
-      files: { vault: 'v' },
-    }),
-    requestTick: (input) => {
-      calls.tick.push(input);
-      return overrides.tick ?? { ok: true, accepted: true };
-    },
-    ask: async (input) => {
-      calls.ask.push(input);
-      return overrides.ask ?? { ok: true, accepted: true, taskId: 'task-1' };
-    },
-    reportHistory: (limit) => {
-      calls.report.push(limit);
-      return {
-        lastReport: { at: '2026-11-04T00:00:00.000Z', summary: 'ok' },
-        reports: Array.from({ length: Math.min(limit, 3) }, (_, index) => ({ summary: `r${index}` })),
-      };
-    },
-  };
-  return { service, calls };
-}
-
-const HOST_PARAM_KEYS = new Set([
-  'description', 'title', 'default', 'examples', 'required',
-  'type', 'enum', 'const', 'items', 'properties', 'additionalProperties', 'oneOf',
-]);
-const HOST_VALUE_TYPES = new Set(['json', 'object', 'array', 'string', 'number', 'integer', 'boolean', 'null']);
-const FORBIDDEN_TOP_LEVEL = ['type', 'properties', 'required', 'additionalProperties', 'items', 'oneOf', 'enum', 'minLength', 'maxLength', 'minimum', 'maximum', 'minItems', 'maxItems'];
-
-function assertValueSchema(schema, path) {
-  assert.ok(typeof schema === 'object' && schema !== null && !Array.isArray(schema), `${path} must be a schema object`);
-  for (const key of Object.keys(schema)) {
-    assert.equal(HOST_PARAM_KEYS.has(key), true, `${path}.${key} is not in the host value-schema DSL`);
-  }
-  if (Object.hasOwn(schema, 'required')) assert.equal(schema.required, true, `${path}.required must be true`);
-  if (Object.hasOwn(schema, 'oneOf')) {
-    assert.equal(Object.hasOwn(schema, 'type'), false, `${path} cannot have both type and oneOf`);
-    assert.ok(Array.isArray(schema.oneOf) && schema.oneOf.length >= 2, `${path}.oneOf needs >= 2 branches`);
-    schema.oneOf.forEach((branch, index) => assertValueSchema(branch, `${path}.oneOf[${index}]`));
-    return;
-  }
-  assert.equal(HOST_VALUE_TYPES.has(schema.type), true, `${path}.type must be a host value type`);
-  if (Object.hasOwn(schema, 'items')) assertValueSchema(schema.items, `${path}.items`);
-  if (Object.hasOwn(schema, 'properties')) {
-    for (const [key, value] of Object.entries(schema.properties)) assertValueSchema(value, `${path}.properties.${key}`);
-  }
-}
-
-/** Host contract: `parameters` is a map of argument name -> value schema, never a JSON Schema object. */
-function assertHostParameters(parameters, name) {
-  assert.ok(typeof parameters === 'object' && parameters !== null && !Array.isArray(parameters), `${name}.parameters must be a map`);
-  for (const forbidden of FORBIDDEN_TOP_LEVEL) {
-    assert.equal(Object.hasOwn(parameters, forbidden), false, `${name}.parameters.${forbidden} must not appear at the top level`);
-  }
-  for (const [key, schema] of Object.entries(parameters)) assertValueSchema(schema, `${name}.parameters.${key}`);
-}
-
-test('the four router tools have the DESIGN names, host-shaped parameter maps and a text renderer', () => {
-  const { service } = fakeService();
-  const tools = createRouterTools(service);
-  assert.deepEqual(tools.map((tool) => tool.name), [
-    'router_status',
-    'router_tick',
-    'router_ask',
-    'router_report',
-  ]);
-  for (const tool of tools) {
-    assertHostParameters(tool.parameters, tool.name);
-    assert.equal(tool.output.schema.type, 'object');
-    const rendered = tool.output.render({}, { ok: true, value: 1 });
-    assert.equal(Array.isArray(rendered), true);
-    assert.equal(rendered[0].type, 'text');
-  }
-});
-
-test('router_status returns a read-only snapshot without waking the router', async () => {
-  const { service, calls } = fakeService();
-  const status = createRouterTools(service).find((tool) => tool.name === 'router_status');
-  const result = await status.invoke({}, {});
-  assert.equal(result.ok, true);
-  assert.equal(result.state, 'running');
-  assert.equal(result.run.capTokens, 5000);
-  assert.equal(calls.tick.length, 0);
-  assert.equal(calls.ask.length, 0);
-});
-
-test('router_tick maps the tier, forwards caller, and preserves E_BUSY', async () => {
-  const { service, calls } = fakeService({ tick: { ok: false, code: 'E_BUSY', state: 'running' } });
-  const tick = createRouterTools(service).find((tool) => tool.name === 'router_tick');
-  const busy = await tick.invoke({ tier: 'reflect' }, { exec: { caller: 'session-1' } });
-  assert.deepEqual(busy, { ok: false, code: 'E_BUSY', state: 'running' });
-  assert.equal(calls.tick[0].tier, 'reflect');
-  assert.equal(calls.tick[0].manual, true);
-  assert.equal(calls.tick[0].reason, 'tool');
-  assert.equal(calls.tick[0].caller, 'session-1');
-});
-
-test('router_ask rejects a blank question and forwards a valid one with the default tier', async () => {
-  const { service, calls } = fakeService();
-  const ask = createRouterTools(service).find((tool) => tool.name === 'router_ask');
-  const blank = await ask.invoke({ question: '   ' }, {});
-  assert.equal(blank.ok, false);
-  assert.equal(blank.code, 'E_INVALID_QUESTION');
-  assert.equal(calls.ask.length, 0);
-
-  const ok = await ask.invoke({ question: '现在该做什么？' }, {});
-  assert.equal(ok.ok, true);
-  assert.equal(ok.taskId, 'task-1');
-  assert.equal(calls.ask[0].question, '现在该做什么？');
-  assert.equal(calls.ask[0].tier, 'full');
-});
-
-test('router_report defaults to 5 and passes an explicit limit through', async () => {
-  const { service, calls } = fakeService();
-  const report = createRouterTools(service).find((tool) => tool.name === 'router_report');
-  const first = await report.invoke({}, {});
-  assert.equal(first.ok, true);
-  assert.equal(first.state, 'running');
-  assert.equal(calls.report[0], 5);
-  await report.invoke({ limit: 2 }, {});
-  assert.equal(calls.report[1], 2);
-});
-
-test('all router tools (incl. proposal layer) expose host-honest value schemas', () => {
-  const { service } = fakeService();
-  service.config = { enabled: true, proposalEnabled: true };
-  const tools = createRouterTools(service);
-  assert.deepEqual(tools.map((tool) => tool.name), [
-    'router_status', 'router_tick', 'router_ask', 'router_report',
-    'router_propose', 'router_proposals', 'router_apply',
-  ]);
-  for (const tool of tools) assertHostParameters(tool.parameters, tool.name);
-
-  const byName = new Map(tools.map((tool) => [tool.name, tool]));
-  const propose = byName.get('router_propose').parameters;
-  for (const required of ['op', 'target', 'title', 'content']) {
-    assert.equal(propose[required].required, true, `router_propose.${required} must be required`);
-  }
-  assert.deepEqual(propose.priority.enum, ['P0', 'P1', 'P2', 'P3', 'P4']);
-  assert.equal(byName.get('router_apply').parameters.mode.required, true);
-  assert.equal(byName.get('router_ask').parameters.question.required, true);
-  // Length/count limits are enforced in code; the host DSL has no such keywords.
-  const text = JSON.stringify(tools.map((tool) => tool.parameters));
-  for (const keyword of ['minLength', 'maxLength', 'minimum', 'maximum', 'maxItems', 'minItems']) {
-    assert.equal(text.includes(`"${keyword}"`), false, `${keyword} must not leak into tool schemas`);
-  }
-});

package/test/router-1100/turn-reflect-tick.test.mjs

@@ -1,89 +0,0 @@
-// C-02 / C-06: turn/end reflect 轻量整理必须真的跑一次模型；running 时
-// status.nextTickAt 必须保持为下一次定时 tick（不能因为空队列被置 null）。
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import test from 'node:test';
-
-import { makeService, startedService } from './helpers.mjs';
-
-const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
-function auditRecords(vaultDir) {
-  const file = path.join(vaultDir, 'audit.jsonl');
-  if (!fs.existsSync(file)) return [];
-  return fs.readFileSync(file, 'utf8').trim().split('\n').filter(Boolean).map((line) => JSON.parse(line));
-}
-
-test('C-02: turn/end completed enqueues a synthetic reflect pass with exactly one model call', async () => {
-  const env = await startedService({ deps: { turnDebounceMs: 5 } });
-  try {
-    assert.equal(env.result.state, 'running');
-    const delivered = env.service.handleSessionEvent({ type: 'turn/end', data: { reason: { kind: 'completed' }, turn: 1 } });
-    assert.equal(delivered.scheduled, true);
-
-    for (let i = 0; i < 100 && env.llm.calls === 0; i += 1) await sleep(5);
-    assert.equal(env.llm.calls, 1, 'turn/end reflect must call the model once');
-
-    const records = auditRecords(env.vaultDir);
-    const starts = records.filter((record) => record.kind === 'task.start');
-    assert.equal(starts.length, 1);
-    assert.equal(starts[0].type, 'reflect');
-    assert.equal(starts[0].tier, 'reflect');
-
-    // error / aborted turns must not trigger a model call.
-    env.service.handleSessionEvent({ type: 'turn/end', data: { reason: { kind: 'error' }, turn: 2 } });
-    env.service.handleSessionEvent({ type: 'turn/end', data: { reason: { kind: 'aborted' }, turn: 3 } });
-    await sleep(40);
-    assert.equal(env.llm.calls, 1, 'error/aborted turns must stay quiet');
-  } finally {
-    await env.service.dispose();
-    env.cleanup();
-  }
-});
-
-test('C-06: running service keeps nextTickAt as the next scheduled tick after an idle tick', async () => {
-  const env = await startedService({
-    config: { tickMs: 60 },
-    deps: { firstTickMs: 5 },
-  });
-  try {
-    assert.equal(env.result.state, 'running');
-    await sleep(20);
-    env.service.nextTickAt = new Date(Date.now() + 30000).toISOString();
-    const before = env.service.status().nextTickAt;
-
-    // Force one idle tick (no queued tasks): the old bug nulled nextTickAt here.
-    const idle = await env.service.tick({ tier: 'reflect', reason: 'test-idle' });
-    assert.equal(idle.ok, true);
-    assert.equal(idle.idle, true);
-    assert.equal(env.service.status().nextTickAt, before, 'idle tick must not null nextTickAt');
-    assert.equal(env.service.status().nextTickAt, before);
-  } finally {
-    await env.service.dispose();
-    env.cleanup();
-  }
-});
-
-test('C-06: a successful tick also keeps nextTickAt (no null on completion)', async () => {
-  const env = await startedService();
-  try {
-    assert.equal(env.result.state, 'running');
-    const scheduled = new Date(Date.now() + 30000).toISOString();
-    env.service.nextTickAt = scheduled;
-    env.service.queue.writer.append({
-      id: 'c06-task-1',
-      type: 'question',
-      payload: { question: 'nextTickAt 保持' },
-      origin: 'test',
-      depth: 0,
-    });
-    const done = await env.service.tick({ tier: 'reflect', reason: 'test-task' });
-    assert.equal(done.ok, true);
-    assert.equal(done.processed, 1);
-    assert.equal(env.service.status().nextTickAt, scheduled, 'successful tick must not null nextTickAt');
-  } finally {
-    await env.service.dispose();
-    env.cleanup();
-  }
-});

package/test/router-1100/v6-contract.test.mjs

@@ -1,158 +0,0 @@
-// 1.1.1 contract checks for the VM-v5 regressions that are cheap to pin
-// locally: ledger `kind` mirror + overshoot accounting (E-01/E-05), the
-// pending/numeric-ticket proposal contract (K-04/N-01), and the bounded
-// E_WAIT_TIMEOUT lease window (L-04).
-
-import assert from 'node:assert/strict';
-import fs from 'node:fs';
-import path from 'node:path';
-import test from 'node:test';
-
-import { BudgetLedger } from '../../src/router/background/budget-ledger.mjs';
-import { makeService, readJson, tempRoot, writeMemory } from './helpers.mjs';
-
-test('v6 E-01: every ledger row carries the VM-facing kind mirror', () => {
-  const temp = tempRoot('v6-ledger-kind-');
-  try {
-    const ledger = new BudgetLedger({ file: path.join(temp, 'budget.ledger.jsonl'), maxTokens: 50000 });
-    const reservation = ledger.reserve({ taskId: 't-kind', tokens: 1000, owner: 'run-v6' });
-    assert.equal(reservation.ok, true);
-    const settled = ledger.settle({ id: reservation.id, tokens: 900 });
-    assert.equal(settled.ok, true);
-    const rows = fs.readFileSync(path.join(temp, 'budget.ledger.jsonl'), 'utf8')
-      .trim().split('\n').map((line) => JSON.parse(line));
-    assert.deepEqual(rows.map((row) => row.kind), ['reserve', 'settle']);
-    assert.deepEqual(rows.map((row) => row.op), ['reserve', 'settle']);
-  } finally {
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-});
-
-test('v6 E-05: allowOvershoot records the real usage instead of truncating it', () => {
-  const temp = tempRoot('v6-ledger-overshoot-');
-  try {
-    const ledger = new BudgetLedger({ file: path.join(temp, 'budget.ledger.jsonl'), maxTokens: 50000 });
-    const reservation = ledger.reserve({ taskId: 't-over', tokens: 1000, owner: 'run-v6' });
-    assert.equal(reservation.ok, true);
-    const settled = ledger.settle({ id: reservation.id, tokens: 40000, allowOvershoot: true });
-    assert.equal(settled.ok, true);
-    assert.equal(settled.applied, 40000);
-    const rows = fs.readFileSync(path.join(temp, 'budget.ledger.jsonl'), 'utf8')
-      .trim().split('\n').map((line) => JSON.parse(line));
-    assert.equal(rows.at(-1).kind, 'settle');
-    assert.equal(rows.at(-1).tokens, 40000);
-    assert.equal(ledger.snapshot().used, 40000);
-  } finally {
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-});
-
-test('v6 K-04/N-01: a new proposal is pending and returns a numeric ticket', async () => {
-  const temp = tempRoot('v6-proposal-pending-');
-  const memoryRoot = path.join(temp, 'memory');
-  fs.mkdirSync(memoryRoot, { recursive: true });
-  writeMemory(memoryRoot);
-  const env = makeService({
-    temp,
-    memoryRoot,
-    vaultDir: path.join(temp, 'vault'),
-    config: { proposalEnabled: true, applyEnabled: true },
-  });
-  try {
-    const started = await env.service.start();
-    assert.equal(started.ok, true, JSON.stringify(started));
-    const proposed = await env.service.proposeProposal({
-      op: 'journal.append',
-      target: 'journal/2026-11.md',
-      title: 'v6 pending',
-      content: 'pending body',
-    }, { caller: { kind: 'root', sessionId: 'root-session' } });
-    assert.equal(proposed.ok, true, JSON.stringify(proposed));
-    assert.equal(proposed.ticket, 1);
-    assert.equal(proposed.ticketName, 'q-0001');
-    const stored = readJson(path.join(env.vaultDir, 'proposals', `${proposed.id}.json`));
-    assert.equal(stored.status, 'pending');
-    assert.equal(stored.queue.ticket, 'q-0001');
-  } finally {
-    await env.service.dispose();
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-});
-
-test('v6 F-05: allowMissingAnchor is visible as a warning and audit row', async () => {
-  const temp = tempRoot('v6-anchor-allowed-');
-  const memoryRoot = path.join(temp, 'memory');
-  fs.mkdirSync(memoryRoot, { recursive: true });
-  writeMemory(memoryRoot);
-  const vaultDir = path.join(temp, 'vault');
-  const seedDir = path.join(vaultDir, 'runs', 'seed-no-anchor');
-  fs.mkdirSync(seedDir, { recursive: true });
-  const ledger = new BudgetLedger({ file: path.join(seedDir, 'budget.ledger.jsonl'), maxTokens: 50000 });
-  const reservation = ledger.reserve({ taskId: 'seed', tokens: 1000, owner: 'seed-run' });
-  ledger.settle({ id: reservation.id, tokens: 900 });
-  const env = makeService({
-    temp,
-    memoryRoot,
-    vaultDir,
-    config: { proposalEnabled: true, allowMissingAnchor: true },
-  });
-  try {
-    const started = await env.service.start();
-    assert.equal(started.ok, true, JSON.stringify(started));
-    assert.equal(env.service.status().state, 'running');
-    assert.ok(env.service.status().warnings.includes('ANCHOR_MISSING_ALLOWED'));
-    const rows = fs.readFileSync(path.join(vaultDir, 'audit.jsonl'), 'utf8')
-      .trim().split('\n').filter(Boolean).map((line) => JSON.parse(line));
-    assert.ok(rows.some((row) => row.kind === 'anchor.missing.allowed'));
-  } finally {
-    await env.service.dispose();
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-});
-
-test('v6 L-04: a short lease window yields E_WAIT_TIMEOUT and blocked-on-user', async () => {
-  const temp = tempRoot('v6-lease-timeout-');
-  const memoryRoot = path.join(temp, 'memory');
-  fs.mkdirSync(memoryRoot, { recursive: true });
-  writeMemory(memoryRoot);
-  const vaultDir = path.join(temp, 'vault');
-  const env = makeService({
-    temp,
-    memoryRoot,
-    vaultDir,
-    config: { proposalEnabled: true, applyEnabled: true, leaseWaitTimeoutMs: 1000 },
-  });
-  try {
-    const started = await env.service.start();
-    assert.equal(started.ok, true, JSON.stringify(started));
-    const proposed = await env.service.proposeProposal({
-      op: 'journal.append',
-      target: 'journal/2026-11.md',
-      title: 'v6 lease',
-      content: 'lease body',
-    }, { caller: { kind: 'root', sessionId: 'root-session' } });
-    assert.equal(proposed.ok, true, JSON.stringify(proposed));
-    await env.service.requestApply({ mode: 'approve', id: proposed.id, confirm: proposed.id.slice(-6) },
-      { caller: { kind: 'root', sessionId: 'root-session' } });
-
-    const held = env.service.lease.acquire({ ticket: 'q-0001', proposalId: proposed.id });
-    assert.equal(held.ok, true, JSON.stringify(held));
-
-    const result = await env.service.requestApply({
-      mode: 'apply',
-      id: proposed.id,
-      confirm: proposed.id.slice(-6),
-    }, { caller: { kind: 'root', sessionId: 'root-session' } });
-    assert.equal(result.ok, false);
-    assert.equal(result.code, 'E_WAIT_TIMEOUT');
-    assert.equal(result.state, 'blocked-on-user');
-    assert.equal(result.reason, 'LEASE_TIMEOUT');
-    const stored = readJson(path.join(vaultDir, 'proposals', `${proposed.id}.json`));
-    assert.equal(stored.status, 'blocked-on-user');
-    assert.equal(stored.reason, 'LEASE_TIMEOUT');
-    assert.equal(fs.existsSync(path.join(memoryRoot, 'journal', '2026-11.md')), false);
-  } finally {
-    await env.service.dispose();
-    fs.rmSync(temp, { recursive: true, force: true });
-  }
-});