dsh-memsys 0.1.0 → 0.2.1

package/test/p6-c1c4.test.mjs

@@ -0,0 +1,69 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { recordDelivery } from '../src/context/delivery.mjs';
+import { getMemories } from '../src/read/get.mjs';
+import {
+  insertCandidate, insertEvidence, insertMemory, insertObservation, insertPointer, insertTimeline,
+} from '../src/storage/repositories.mjs';
+import { createTestContext, makeCandidate, makeMemory, makeObservation, mutableClock } from './helpers/fixtures.mjs';
+
+function deliveryFixture(ctx, { actualIds, expectedIds, receivedIds, hash = 'h' }) {
+  const roundId = 'r-c1';
+  const snapshotId = 'snap-c1';
+  ctx.control
+    .prepare("INSERT OR REPLACE INTO compilations (id, round_id, stream_key, source_revision, policy_revision, delivery_level, payload_hash, section_text, created_at) VALUES (?, ?, 'stream', 0, '1', 'grouped', ?, '', ?)")
+    .run(`comp:${snapshotId}`, roundId, hash, ctx.clock.at().at);
+  ctx.control
+    .prepare("INSERT OR REPLACE INTO context_snapshots (id, compilation_id, round_id, mode, source_revision, policy_revision, delivery_level, eligible_ids, expected_ids, deferred_groups, created_at, expires_at, manifest_json) VALUES (?, ?, ?, 'work', 0, '1', 'grouped', '[]', ?, '[]', ?, ?, ?)")
+    .run(snapshotId, `comp:${snapshotId}`, roundId, JSON.stringify(expectedIds), ctx.clock.at().at, ctx.clock.at().at, JSON.stringify({ expected_ids: expectedIds, actual_ids: actualIds, hashes: { payload: hash } }));
+  return recordDelivery({ main: ctx.main, control: ctx.control, clock: ctx.clock, roundId, snapshotId, receivedIds, payloadHash: hash, manifestHash: 'm', slots: {} });
+}
+
+test('P6/C1: group-only receipt with empty actual set is incomplete', (t) => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  t.after(() => ctx.cleanup());
+  const result = deliveryFixture(ctx, { actualIds: [], expectedIds: ['group:g1'], receivedIds: ['group:g1'] });
+  assert.equal(result.delivery, 'incomplete');
+  assert.equal(result.code, 'receipt_incomplete');
+  assert.notEqual(result.delivery, 'confirmed');
+});
+
+test('P6/C1: non-empty actual set missing one memory is incomplete', (t) => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  t.after(() => ctx.cleanup());
+  const result = deliveryFixture(ctx, { actualIds: ['mem_a', 'mem_b'], expectedIds: ['mem_a', 'mem_b', 'group:g1'], receivedIds: ['mem_a', 'group:g1'] });
+  assert.equal(result.delivery, 'incomplete');
+  assert.equal(result.code, 'receipt_incomplete');
+  assert.deepEqual(result.missing_ids, ['mem_b']);
+});
+
+test('P6/C4: evidence text pages reassemble byte-for-byte', (t) => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  t.after(() => ctx.cleanup());
+  const original = '证据原文'.repeat(600);
+  const observation = makeObservation(ctx, { messageSeq: 30000, text: original });
+  insertObservation(ctx.main, observation);
+  const candidate = makeCandidate(ctx, observation, { businessKey: 'c4', text: '短摘要', why: 'w', type: 'fact', scene: 'work', scope: 'work-only' });
+  insertCandidate(ctx.main, candidate);
+  const memory = makeMemory(ctx, candidate);
+  insertMemory(ctx.main, memory);
+  insertTimeline(ctx.main, { memory_id: memory.id, start_at: null, end_at: null, prec_start: 'unknown', prec_end: 'unknown', time_state: 'point', revision: 1 });
+  insertPointer(ctx.main, { memory_id: memory.id, status: 'unknown', location: null, search_hint: null, lossy: 0, revision: 1 });
+  insertEvidence(ctx.main, { id: 'ev_c4', memory_id: memory.id, candidate_id: null, observation_id: observation.id, source_memory_id: null, role: 'basis', source_span: 'bytes:0:4', at: ctx.clock.at().at });
+
+  let cursor = null;
+  let joined = '';
+  for (let page = 0; page < 20; page += 1) {
+    const result = getMemories({ main: ctx.main, clock: ctx.clock, ids: [memory.id], includeEvidence: true, maxChars: 1000, cursor });
+    assert.equal(result.status, 'ok', JSON.stringify(result));
+    for (const item of result.items) {
+      for (const evidence of item.evidence ?? []) {
+        if (typeof evidence.observation_text === 'string') joined += evidence.observation_text;
+      }
+    }
+    cursor = result.next_cursor;
+    if (!cursor) break;
+  }
+  assert.equal(joined, original);
+});

package/test/p6-c3-append.test.mjs

@@ -0,0 +1,85 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { compileRound } from '../src/context/compile.mjs';
+import { conservativeTokens } from '../src/context/budget.mjs';
+import { getGroupPage } from '../src/context/snapshots.mjs';
+import { ingestInput } from '../src/write/observe.mjs';
+import { promoteCandidate, recordCandidates } from '../src/write/candidate.mjs';
+import { createTestContext, mutableClock } from './helpers/fixtures.mjs';
+import { fakeRuntime } from './helpers/runtime.mjs';
+
+let seq = 0;
+function addMemory(ctx, text) {
+  seq += 1;
+  const runtime = fakeRuntime({ role: 'daily', identity: 'c3a', callId: 'c3a-' + seq, messageSeq: 31000 + seq });
+  const observation = ingestInput(runtime, { text: 'C3-' + seq, messageSeq: 31000 + seq }, { main: ctx.main, control: ctx.control, clock: ctx.clock });
+  const created = recordCandidates(runtime, {
+    items: [{
+      observationId: observation.observation.id,
+      text,
+      why: 'w', type: 'fact', scene: 'work', scope: 'work-only',
+      evidenceRefs: [{ observationId: observation.observation.id, sourceSpan: 'bytes:0:3' }],
+    }],
+  }, { main: ctx.main, control: ctx.control, clock: ctx.clock });
+  promoteCandidate(runtime, created.items[0].id, null, { main: ctx.main, control: ctx.control, clock: ctx.clock });
+}
+
+function make(ctx) {
+  for (let i = 0; i < 12; i += 1) addMemory(ctx, 'C3混版-' + i + '-' + 'x'.repeat(500));
+}
+
+function compile(ctx, roundId) {
+  return compileRound({ main: ctx.main, control: ctx.control, clock: ctx.clock, sessionId: 's-c3a', roundId, mode: 'work', tokenizer: conservativeTokens, H: 300 });
+}
+
+function page(ctx, snapshotRevision, groupId, cursor = null) {
+  return getGroupPage({ control: ctx.control, main: ctx.main, clock: ctx.clock, snapshotRevision, groupId, cursor, maxChars: 1000 });
+}
+
+test('P6/C3: old cursor is stale after an append through the promote path', (t) => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  t.after(() => ctx.cleanup());
+  make(ctx);
+  const first = compile(ctx, 'r-c3a');
+  assert.equal(first.delivery_level, 'grouped', JSON.stringify(first.delivery_level));
+  const groupId = first.groups[0].group_id;
+  const firstPage = page(ctx, first.snapshot_revision, groupId);
+  assert.equal(firstPage.status, 'ok', JSON.stringify(firstPage));
+  assert.ok(firstPage.next_cursor);
+  addMemory(ctx, '追加混版-' + 'y'.repeat(500));
+  const stale = page(ctx, first.snapshot_revision, groupId, firstPage.next_cursor);
+  assert.equal(stale.status, 'error', JSON.stringify(stale));
+  assert.equal(stale.code, 'stale_cursor');
+});
+
+test('P6/C3: same data recompiles to same id; append changes it', (t) => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  t.after(() => ctx.cleanup());
+  make(ctx);
+  const a = compile(ctx, 'r-c3b1');
+  const b = compile(ctx, 'r-c3b2');
+  assert.equal(a.snapshot_revision, b.snapshot_revision);
+  addMemory(ctx, '追加换ID-' + 'z'.repeat(500));
+  const c = compile(ctx, 'r-c3b3');
+  assert.notEqual(c.snapshot_revision, a.snapshot_revision);
+});
+
+test('P6/C3: clean paging reaches the end without stale_cursor', (t) => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  t.after(() => ctx.cleanup());
+  make(ctx);
+  const compiled = compile(ctx, 'r-c3c');
+  const groupId = compiled.groups[0].group_id;
+  let cursor = null;
+  let pages = 0;
+  for (;;) {
+    const result = page(ctx, compiled.snapshot_revision, groupId, cursor);
+    assert.equal(result.status, 'ok', JSON.stringify(result));
+    pages += 1;
+    cursor = result.next_cursor;
+    if (!cursor) break;
+    assert.ok(pages < 100);
+  }
+  assert.ok(pages >= 1);
+});

package/test/p6-inject-round.test.mjs

@@ -0,0 +1,76 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { EventEmitter } from 'node:events';
+
+import { createRoundInjector } from '../src/runtime/inject-round.mjs';
+import { compileRound } from '../src/context/compile.mjs';
+import { conservativeTokens } from '../src/context/budget.mjs';
+import { ingestInput } from '../src/write/observe.mjs';
+import { promoteCandidate, recordCandidates } from '../src/write/candidate.mjs';
+import { createTestContext, mutableClock } from './helpers/fixtures.mjs';
+import { fakeRuntime } from './helpers/runtime.mjs';
+
+function seed(ctx, index) {
+  const runtime = fakeRuntime({ role: 'daily', identity: 'inj', callId: 'inj-' + index, messageSeq: 28000 + index });
+  const observation = ingestInput(runtime, { text: '注入目录记忆-' + index, messageSeq: 28000 + index }, { main: ctx.main, control: ctx.control, clock: ctx.clock });
+  const created = recordCandidates(runtime, {
+    items: [{
+      observationId: observation.observation.id,
+      text: '注入目录记忆-' + index,
+      why: 'w', type: 'fact', scene: 'work', scope: 'work-only',
+      evidenceRefs: [{ observationId: observation.observation.id, sourceSpan: 'bytes:0:5' }],
+    }],
+  }, { main: ctx.main, control: ctx.control, clock: ctx.clock });
+  promoteCandidate(runtime, created.items[0].id, null, { main: ctx.main, control: ctx.control, clock: ctx.clock });
+}
+
+test('P6/inject-round: turn/start refreshes an empty directory into compiled memory ids', (t) => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  t.after(() => ctx.cleanup());
+  seed(ctx, 1);
+  const bus = new EventEmitter();
+  const injector = createRoundInjector({
+    ctx: bus,
+    handles: ctx.handles,
+    modules: { context: true },
+    compileRound,
+    tokenizer: conservativeTokens,
+    H: 1000,
+    clock: ctx.clock,
+  });
+  t.after(() => injector.dispose());
+  assert.equal(injector.current().text, '');
+  bus.emit('session/event', { type: 'turn/start', session: { header: { id: 'session-inj' } }, id: 'turn-1' });
+  const current = injector.current();
+  assert.ok(current.text.length > 0, JSON.stringify(current));
+  assert.ok(current.manifest.eligible_ids.length > 0, JSON.stringify(current.manifest));
+  assert.equal(current.delivery, 'unknown');
+});
+
+test('P6/inject-round: missing tokenizer/H falls back to tools-only and never pretends delivery', () => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  try {
+    const injector = createRoundInjector({ ctx: { on() {} }, handles: ctx.handles, modules: {}, compileRound, tokenizer: null, H: null, clock: ctx.clock });
+    injector.refresh({ session: { header: { id: 's' } }, id: 't' });
+    assert.equal(injector.current().delivery_level, 'unavailable');
+    assert.equal(injector.current().delivery, 'unknown');
+    assert.match(injector.current().text, /tools-only/);
+  } finally {
+    ctx.cleanup();
+  }
+});
+
+test('P6/inject-round: context=false yields empty text and does not subscribe', () => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  try {
+    let subscribed = false;
+    const bus = { on() { subscribed = true; } };
+    const injector = createRoundInjector({ ctx: bus, handles: ctx.handles, modules: { context: false }, compileRound, tokenizer: conservativeTokens, H: 1000, clock: ctx.clock });
+    injector.refresh({ id: 't' });
+    assert.equal(injector.current().text, '');
+    assert.equal(injector.current().delivery_level, 'disabled');
+    assert.equal(subscribed, false);
+  } finally {
+    ctx.cleanup();
+  }
+});

package/test/p6-l6-rollback.test.mjs

@@ -0,0 +1,38 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import {
+  compareBusinessRows,
+  compareDatabaseFreeze,
+  snapshotBusinessRows,
+  snapshotDatabaseFreeze,
+} from '../src/import/rollback.mjs';
+import { createTestContext, mutableClock } from './helpers/fixtures.mjs';
+
+test('P6/L6: rollback detects changed row content even when counts match', (t) => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  t.after(() => ctx.cleanup());
+  ctx.main
+    .prepare("INSERT INTO observations (id, idempotency_key, at, payload_hash, text, source, author_kind, runtime_refs, origin, lossy, state_snapshot, initial_strength, recorded_at) VALUES ('obs_l6_content','obs:l6c',?, 'h','原始内容','file','unknown','{}','migrated',0,'{}',0.5,?)")
+    .run(ctx.clock.at().at, ctx.clock.at().at);
+  const baseline = snapshotBusinessRows(ctx.main);
+  ctx.main.exec('DROP TRIGGER IF EXISTS trg_observations_no_update');
+  ctx.main.prepare('UPDATE observations SET text = ? WHERE id = ?').run('改过的内容', 'obs_l6_content');
+  const compared = compareBusinessRows({ db: ctx.main, baseline });
+  assert.equal(compared.ok, false, 'same count must not pass when content changed');
+  assert.ok(compared.missing.some((entry) => entry.includes('content')), JSON.stringify(compared));
+});
+
+test('P6/L6: boundary freeze detects changed content with unchanged counts', (t) => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  t.after(() => ctx.cleanup());
+  ctx.main
+    .prepare("INSERT INTO observations (id, idempotency_key, at, payload_hash, text, source, author_kind, runtime_refs, origin, lossy, state_snapshot, initial_strength, recorded_at) VALUES ('obs_l6_freeze','obs:l6f',?, 'h','原始','file','unknown','{}','migrated',0,'{}',0.5,?)")
+    .run(ctx.clock.at().at, ctx.clock.at().at);
+  const freeze = snapshotDatabaseFreeze(ctx.handles);
+  ctx.main.exec('DROP TRIGGER IF EXISTS trg_observations_no_update');
+  ctx.main.prepare('UPDATE observations SET text = ? WHERE id = ?').run('改过', 'obs_l6_freeze');
+  const compared = compareDatabaseFreeze(ctx.handles, freeze);
+  assert.equal(compared.ok, false);
+  assert.ok(compared.missing.some((entry) => entry.includes('content')), JSON.stringify(compared));
+});

package/test/p6-modules.test.mjs

@@ -0,0 +1,77 @@
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { moduleEnabled, resolveModules } from '../src/runtime/modules.mjs';
+import { toolDefinitions } from '../src/runtime/tools.mjs';
+import { compileRound } from '../src/context/compile.mjs';
+import { conservativeTokens } from '../src/context/budget.mjs';
+import {
+  insertCandidate, insertMemory, insertObservation, insertPointer, insertTimeline,
+} from '../src/storage/repositories.mjs';
+import { createTestContext, makeCandidate, makeMemory, makeObservation, mutableClock } from './helpers/fixtures.mjs';
+
+let seq = 0;
+function pendingMemory(ctx) {
+  seq += 1;
+  const text = '待确认惦记';
+  const observation = makeObservation(ctx, { messageSeq: 27000 + seq, text });
+  insertObservation(ctx.main, observation);
+  const candidate = makeCandidate(ctx, observation, { businessKey: `mod-${seq}`, text, why: '期限', type: 'promise', scene: 'work', scope: 'work-only' });
+  insertCandidate(ctx.main, candidate);
+  const memory = makeMemory(ctx, candidate);
+  Object.assign(memory, { due_state: 'pending-due', scene: 'work', scope: 'work-only' });
+  insertMemory(ctx.main, memory);
+  insertTimeline(ctx.main, { memory_id: memory.id, start_at: null, end_at: null, prec_start: 'unknown', prec_end: 'unknown', time_state: 'point', revision: 1 });
+  insertPointer(ctx.main, { memory_id: memory.id, status: 'unknown', location: null, search_hint: null, lossy: 0, revision: 1 });
+  ctx.main
+    .prepare("INSERT INTO due_queue (memory_id, due_state, enqueued_seq, enqueued_at, opened_at, deadline_at, revision, reason) VALUES (?, 'pending-due', 1, ?, NULL, NULL, 0, 'promote')")
+    .run(memory.id, ctx.clock.at().at);
+  return memory;
+}
+
+test('P6/modules: defaults enable everything and register all 10 tools', () => {
+  const modules = resolveModules({});
+  assert.deepEqual(modules, {
+    context: true, read: true, write: true, dream: true, projects: true, due: true, feed: true,
+  });
+  assert.equal(toolDefinitions({}, modules).length, 10);
+});
+
+test('P6/modules: read=false removes read tools but keeps write/dream/feed', () => {
+  const modules = resolveModules({ modules: { read: false } });
+  const names = toolDefinitions({}, modules).map((tool) => tool.name);
+  for (const name of ['memsys_get', 'memsys_search', 'memsys_review_get', 'memsys_context_get', 'memsys_project_get', 'memsys_self_get']) {
+    assert.ok(!names.includes(name), name);
+  }
+  assert.ok(names.includes('memsys_record'));
+  assert.ok(names.includes('memsys_dream_record'));
+  assert.ok(names.includes('memsys_feed'));
+});
+
+test('P6/modules: context=false disables the injection section', () => {
+  const modules = resolveModules({ modules: { context: false } });
+  assert.equal(moduleEnabled(modules, 'context'), false);
+  assert.equal(moduleEnabled(modules, 'read'), true);
+});
+
+test('P6/modules: due=false removes review:* typed items from compile output', (t) => {
+  const ctx = createTestContext({ clock: mutableClock().clock });
+  t.after(() => ctx.cleanup());
+  const memory = pendingMemory(ctx);
+  const base = { main: ctx.main, control: ctx.control, clock: ctx.clock, sessionId: 's-mod', roundId: 'r-mod', mode: 'work', tokenizer: conservativeTokens, H: 200000 };
+  const enabled = compileRound(base);
+  assert.ok(enabled.eligible_ids.includes('review:due:' + memory.id), JSON.stringify(enabled.eligible_ids));
+  const disabled = compileRound({ ...base, roundId: 'r-mod2', modules: { due: false } });
+  assert.ok(!disabled.eligible_ids.some((id) => id.startsWith('review:')), JSON.stringify(disabled.eligible_ids));
+});
+
+test('P6/modules: legacy auto_inject maps to context without disabling other modules', () => {
+  const modules = resolveModules({ auto_inject: true });
+  assert.equal(modules.context, true);
+  assert.equal(modules.read, true);
+  assert.equal(modules.write, true);
+  assert.equal(modules.dream, true);
+  assert.equal(modules.projects, true);
+  assert.equal(modules.due, true);
+  assert.equal(modules.feed, true);
+});