@theseus-whale/dsh-continuity 0.0.0-stage → 4.12.2

package/bin/memory-event-alias-test.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+/**
+ * Event-bound alias scenarios: same-event repeat, cross-event repeat,
+ * assistant-only, role change, accommodation.
+ */
+import { EventSegmenter } from '../src/memory/event-segmenter.mjs';
+import { EventAliasLedger } from '../src/memory/event-alias-ledger.mjs';
+
+const run = { activity: '跑团', topic: '剧情' };
+const dev = { activity: '开发', topic: '技术' };
+
+const scenarios = [
+  {
+    id: 'same-event-vs-cross-event',
+    steps: [
+      { text: '我们开个新团，叫星港', facets: run, term: '星港', role: 'campaign', target: '跑团', expected: 'none' },
+      { text: '星港的规则是掷骰', facets: run, term: '星港', role: 'campaign', target: '跑团', expected: 'none' },
+      { text: '先写文档', facets: dev, expected: 'none' },
+      { text: '回到星港', facets: run, term: '星港', role: 'campaign', target: '跑团', expected: 'propose' },
+    ],
+  },
+  {
+    id: 'assistant-only',
+    steps: [
+      { text: '星港开场', facets: run, term: '星港', role: 'campaign', target: '跑团', source: 'assistant', expected: 'none' },
+      { text: '星港的钟楼', facets: run, term: '星港', role: 'campaign', target: '跑团', source: 'assistant', expected: 'none' },
+      { text: '先写文档', facets: dev, expected: 'none' },
+      { text: '星港还在', facets: run, term: '星港', role: 'campaign', target: '跑团', source: 'assistant', expected: 'none' },
+    ],
+  },
+  {
+    id: 'role-change',
+    steps: [
+      { text: '新团叫星港', facets: run, term: '星港', role: 'campaign', target: '跑团', expected: 'none' },
+      { text: '先写文档', facets: dev, expected: 'none' },
+      { text: '星港的灯亮了', facets: run, term: '星港', role: 'location', target: '跑团', expected: 'none' },
+    ],
+  },
+  {
+    id: 'accommodation',
+    steps: [
+      { text: '新规则叫潮汐语法', facets: dev, term: '潮汐语法', role: 'rule', target: null, expected: 'none' },
+      { text: '开始跑团', facets: run, expected: 'none' },
+      { text: '潮汐语法还在', facets: dev, term: '潮汐语法', role: 'rule', target: null, expected: 'accommodate' },
+    ],
+  },
+];
+
+const output = [];
+for (const scenario of scenarios) {
+  const segmenter = new EventSegmenter();
+  const ledger = new EventAliasLedger();
+  const events = [];
+  scenario.steps.forEach((step, index) => {
+    const nowTurn = index + 1;
+    const segment = segmenter.observe({ facets: step.facets, nowTurn });
+    const alias = step.term === undefined
+      ? { action: 'none', reason: 'no-term' }
+      : ledger.observe({
+        term: step.term,
+        source: step.source ?? 'user',
+        eventId: segment.eventId,
+        role: step.role,
+        target: step.target,
+        nowTurn,
+      });
+    events.push({
+      text: step.text,
+      eventId: segment.eventId,
+      boundary: segment.boundary,
+      alias: alias.action,
+      aliasReason: alias.reason,
+      expected: step.expected,
+      pass: alias.action === step.expected,
+      textHint: alias.text ?? null,
+    });
+  });
+  output.push({
+    id: scenario.id,
+    pass: events.every((event) => event.pass),
+    events,
+  });
+}
+const summary = {
+  scenarios: output.length,
+  pass: output.filter((item) => item.pass).length,
+  failures: output.filter((item) => !item.pass).map((item) => item.id),
+};
+console.log(JSON.stringify({ summary, output }, null, 2));

package/bin/memory-extraction-bench.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+/**
+ * Extract-bench harness. Fixtures: JSONL with {text, language?, entities:[...]}.
+ * Provider: a JS module exporting extract(text, route) or {zh,en,mixed} functions.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { createExtractionCore } from '../src/memory/extraction-core.mjs';
+import { scoreEntities, aggregateScores } from '../src/memory/extraction-score.mjs';
+
+const args = process.argv.slice(2);
+const argOf = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+};
+const fixturesPath = argOf('--fixtures');
+const providerPath = argOf('--provider');
+const outPath = argOf('--out') ?? null;
+if (!fixturesPath || !providerPath) {
+  console.error('usage: node bin/memory-extraction-bench.mjs --fixtures dev.jsonl --provider provider.mjs [--out result.json]');
+  process.exit(2);
+}
+const mod = await import(pathToFileURL(path.resolve(providerPath)).href);
+const provider = mod.default ?? mod.provider ?? mod;
+const providers = typeof provider === 'function'
+  ? { zh: provider, en: provider, mixed: provider }
+  : provider;
+const core = createExtractionCore({ providers });
+const fixtures = fs.readFileSync(fixturesPath, 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line.replace(/^\uFEFF/, '')));
+const rows = [];
+for (const fixture of fixtures) {
+  const result = core.extract(fixture.text);
+  const predicted = result.ok ? result.entities : [];
+  const score = scoreEntities(predicted, fixture.entities ?? []);
+  rows.push({
+    text: fixture.text,
+    language: result.language,
+    ok: result.ok,
+    reason: result.reason ?? null,
+    predicted: predicted.length,
+    expected: fixture.entities?.length ?? 0,
+    score,
+  });
+}
+const byLanguage = {};
+for (const language of [...new Set(rows.map((row) => row.language))]) {
+  byLanguage[language] = aggregateScores(rows.filter((row) => row.language === language).map((row) => row.score));
+}
+const output = {
+  fixtures: rows.length,
+  failed: rows.filter((row) => !row.ok).length,
+  aggregate: aggregateScores(rows.map((row) => row.score)),
+  byLanguage,
+  rows,
+};
+if (outPath) fs.writeFileSync(outPath, JSON.stringify(output, null, 2));
+console.log(JSON.stringify({ fixtures: output.fixtures, failed: output.failed, aggregate: output.aggregate, byLanguage }, null, 2));

package/bin/memory-load-gate-replay.mjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+/**
+ * Load-gate replay + fuzz at 50 / 200 / 800 / 1500.
+ * Checks decisions, scene purity and duplicate loads.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { readEventLog } from '../src/memory/event-log.mjs';
+import {
+  MemoryLoadState,
+  latestCandidate,
+  candidateSegment,
+  isSceneRecord,
+} from '../src/memory/load-gate.mjs';
+
+const args = process.argv.slice(2);
+const argOf = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+};
+const dir = argOf('--dir');
+if (!dir) {
+  console.error('usage: node bin/memory-load-gate-replay.mjs --dir .durable-memory');
+  process.exit(2);
+}
+const records = readEventLog(path.join(dir, 'events.jsonl'));
+const checkpoints = [50, 200, 800, 1500];
+const dev = { activity: '开发', topic: '技术' };
+const run = { activity: '跑团', topic: '剧情' };
+
+const scenarios = [
+  { id: 'start-run', text: '我们现在开始跑团吧', facets: run, expected: 'load' },
+  { id: 'plain-start', text: '开始跑团', facets: run, expected: 'load' },
+  { id: 'open-table', text: '开团', facets: run, expected: 'load' },
+  { id: 'coo-start', text: 'Coo：来一局', facets: run, expected: 'load', role: 'coo' },
+  { id: 'meta-rules', text: '规则怎么写', facets: dev, expected: 'none' },
+  { id: 'ordinary-mention', text: '跑团这个设计挺有意思', facets: dev, expected: 'none' },
+  { id: 'generic-start', text: '开始写文档', facets: dev, expected: 'none' },
+  { id: 'recall-run', text: '上次跑团怎么样了', facets: run, expected: 'load' },
+  { id: 'recall-vague', text: '之前那个呢', facets: run, expected: 'load' },
+  { id: 'new-scene', text: '灯室见', facets: run, expected: 'hint' },
+  { id: 'coo-new-scene', text: 'Coo：灯室见', facets: run, expected: 'load', role: 'coo' },
+  { id: 'same-scene', text: '我推门进去', facets: run, expected: 'none', initial: run },
+  { id: 'assistant', text: '开始跑团', facets: run, expected: 'none', role: 'assistant' },
+  { id: 'low-confidence', text: '开始跑团', facets: run, expected: 'none', confidence: 0.3 },
+];
+
+const output = [];
+for (const checkpoint of checkpoints) {
+  const visible = records.filter((record) => record.turn <= checkpoint);
+  const actual = [];
+  const state = new MemoryLoadState();
+  for (const record of visible) {
+    const prior = visible.filter((item) => item.turn < record.turn);
+    const candidate = latestCandidate(prior, 'activity', record.facets.activity);
+    const result = state.decide({
+      text: record.text,
+      currentFacets: record.facets,
+      confidence: 0.9,
+      nowTurn: record.turn,
+      hasCandidate: candidate !== null,
+      candidate,
+    });
+    if (result.action === 'load') {
+      const segment = candidateSegment(visible, candidate);
+      actual.push({
+        turn: record.turn,
+        reason: result.reason,
+        candidateTurn: candidate?.turn ?? null,
+        pure: candidate === null ? false : isSceneRecord(candidate),
+        segmentTurns: segment?.turns ?? 0,
+      });
+      state.recordLoad({ facets: record.facets, seq: segment?.seqStart ?? null, nowTurn: record.turn, reason: result.reason });
+    } else if (result.action === 'hint') {
+      actual.push({ turn: record.turn, reason: result.reason, hint: true });
+    }
+  }
+
+  const fuzz = [];
+  for (const testCase of scenarios) {
+    const candidate = latestCandidate(visible, 'activity', testCase.facets.activity);
+    const segment = candidateSegment(visible, candidate);
+    const testState = new MemoryLoadState({ loadedFacets: testCase.initial ?? dev, loadedAtTurn: checkpoint - 1 });
+    const result = testState.decide({
+      text: testCase.text,
+      currentFacets: testCase.facets,
+      confidence: testCase.confidence ?? 0.9,
+      nowTurn: checkpoint,
+      hasCandidate: candidate !== null,
+      candidate,
+      role: testCase.role ?? 'user',
+    });
+    const pass = (testCase.expected === 'load' && result.action === 'load')
+      || (testCase.expected === 'none' && result.action === 'none')
+      || (testCase.expected === 'hint' && result.action === 'hint');
+    fuzz.push({
+      id: testCase.id,
+      expected: testCase.expected,
+      actual: result.action,
+      reason: result.reason,
+      pass,
+      candidateTurn: candidate?.turn ?? null,
+      candidatePure: candidate === null ? false : isSceneRecord(candidate),
+      segmentTurns: segment?.turns ?? 0,
+    });
+  }
+
+  const loads = actual.filter((item) => item.hint !== true);
+  output.push({
+    checkpoint,
+    visible: visible.length,
+    naturalLoads: loads.length,
+    naturalHints: actual.filter((item) => item.hint === true).length,
+    impureLoads: loads.filter((item) => !item.pure).length,
+    impureSample: loads.filter((item) => !item.pure).slice(0, 6),
+    duplicateActivityLoads: loads.filter((item, index) => index > 0
+      && item.reason === 'activity-change'
+      && loads[index - 1].reason === 'activity-change').length,
+    fuzzPass: fuzz.filter((item) => item.pass).length,
+    fuzzTotal: fuzz.length,
+    fuzzFailures: fuzz.filter((item) => !item.pass),
+    impureCandidates: fuzz.filter((item) => !item.candidatePure).map((item) => item.id),
+    naturalSample: loads.slice(0, 4),
+    fuzz,
+  });
+}
+const result = { dir, output };
+fs.writeFileSync(path.join(dir, 'LOAD-GATE-REPLAY.json'), JSON.stringify(result, null, 2));
+console.log(JSON.stringify(output.map((entry) => ({
+  checkpoint: entry.checkpoint,
+  naturalLoads: entry.naturalLoads,
+  naturalHints: entry.naturalHints,
+  impureLoads: entry.impureLoads,
+  duplicateActivityLoads: entry.duplicateActivityLoads,
+  fuzzPass: `${entry.fuzzPass}/${entry.fuzzTotal}`,
+  fuzzFailures: entry.fuzzFailures.map((item) => item.id),
+})), null, 2));

package/bin/memory-loop-test.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * Real-data checkpoint loop: 50 / 200 / 800 / 1500 turns.
+ * Simulates "上次的 X 怎么样了" and records route, load size, future leaks,
+ * latest-hit correctness, noise and misses.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { readEventLog } from '../src/memory/event-log.mjs';
+import { BM25Index } from '../src/memory/bm25.mjs';
+import { VectorIndex } from '../src/memory/vector-index.mjs';
+import { buildSummaryTree } from '../src/memory/summary-tree.mjs';
+import { buildPlanner, summaryIndex } from '../src/memory/planner.mjs';
+import { embedTexts } from '../src/facets/embedding.mjs';
+
+const args = process.argv.slice(2);
+const argOf = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+};
+const dir = argOf('--dir') ?? 'C:/Users/35794/Documents/DeepSeek\'s Sandbox/coopanion-continuity/backups/continuity-tags-20261031/durable-memory/build-a';
+const records = readEventLog(path.join(dir, 'events.jsonl'));
+const embeddings = JSON.parse(fs.readFileSync('C:/Users/35794/Documents/DeepSeek\'s Sandbox/coopanion-continuity/backups/continuity-tags-20261031/online400/embeddings-1500.json', 'utf8'));
+const vectorByTurn = new Map(embeddings.map((row) => [row.turn, row.vector]));
+const cases = [
+  ['上次的跑团怎么样了', (r) => r.facets.activity === '跑团'],
+  ['上次的TAG闸是什么', (r) => /tag/i.test(r.text) && /闸/.test(r.text)],
+  ['上次的头像呢', (r) => r.facets.medium === '图像'],
+  ['上次的上下文折叠', (r) => /上下文/.test(r.text) && /折叠/.test(r.text)],
+  ['上次手抖是哪轮', (r) => /手抖/.test(r.text)],
+  ['上次的灯室', (r) => /灯室/.test(r.text)],
+  ['上次 沈砚 七把钥匙', (r) => /沈砚/.test(r.text) && /七把钥匙/.test(r.text)],
+  ['上次 dsh-continuity-0.1.0.tgz', (r) => /dsh-continuity-0\.1\.0\.tgz/.test(r.text)],
+  ['上次 C v5', (r) => /C v5/.test(r.text)],
+  ['上次量子计算', () => false],
+];
+const queryVectors = new Map();
+for (const [query] of cases) {
+  const [vector] = await embedTexts([query]);
+  queryVectors.set(query, vector);
+}
+const checkpoints = [50, 200, 800, 1500];
+const output = [];
+for (const checkpoint of checkpoints) {
+  const visible = records.filter((record) => record.turn <= checkpoint);
+  const bm25 = new BM25Index().build(visible);
+  const vectors = new VectorIndex().build(visible, vectorByTurn);
+  const tree = buildSummaryTree(visible);
+  const planner = buildPlanner({ records: visible, bm25, vectorIndex: vectors, summaryBm25: summaryIndex(tree) });
+  const rows = [];
+  for (const [query, predicate] of cases) {
+    const expected = visible.filter(predicate).map((record) => record.turn);
+    const expectedSet = new Set(expected);
+    const plan = planner.query(query, { queryVector: queryVectors.get(query), topK: 10, asOf: checkpoint });
+    const loaded = plan.fused.map((hit) => visible.find((record) => record.turn === hit.turn)).filter(Boolean);
+    const turns = loaded.map((record) => record.turn);
+    const expectedHits = turns.filter((turn) => expectedSet.has(turn));
+    const futureLeak = turns.filter((turn) => turn > checkpoint);
+    const latestExpected = expected.length === 0 ? null : Math.max(...expected);
+    rows.push({
+      query,
+      route: plan.route,
+      expected: expected.length,
+      latestExpected,
+      returned: turns.length,
+      expectedHits: expectedHits.length,
+      latestHit: latestExpected === null ? null : turns.includes(latestExpected),
+      futureLeak: futureLeak.length,
+      noise: turns.length - expectedHits.length,
+      chars: loaded.reduce((sum, record) => sum + record.text.length, 0),
+      top: turns.slice(0, 5),
+    });
+  }
+  output.push({ checkpoint, visible: visible.length, rows });
+}
+const summary = {
+  checkpoints: output.map((entry) => ({
+    checkpoint: entry.checkpoint,
+    visible: entry.visible,
+    futureLeaks: entry.rows.reduce((sum, row) => sum + row.futureLeak, 0),
+    latestMiss: entry.rows.filter((row) => row.latestHit === false).map((row) => row.query),
+    emptyFalse: entry.rows.filter((row) => row.expected === 0 && row.returned > 0).map((row) => row.query),
+    misses: entry.rows.filter((row) => row.expected > 0 && row.expectedHits === 0).map((row) => row.query),
+    noise: entry.rows.reduce((sum, row) => sum + row.noise, 0),
+    chars: entry.rows.reduce((sum, row) => sum + row.chars, 0),
+  })),
+};
+const result = { summary, output };
+fs.writeFileSync(path.join(dir, 'LOOP-CHECKPOINTS.json'), JSON.stringify(result, null, 2));
+console.log(JSON.stringify(summary, null, 2));

package/bin/memory-pre-turn-harness.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+/**
+ * Offline pre-turn harness: scripted user/Coo messages through the integration
+ * layer. No live session and no writes.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { readEventLog } from '../src/memory/event-log.mjs';
+import { PreTurnController } from '../src/memory/pre-turn.mjs';
+import { MemoryLoadState } from '../src/memory/load-gate.mjs';
+
+const args = process.argv.slice(2);
+const argOf = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+};
+const dir = argOf('--dir');
+if (!dir) {
+  console.error('usage: node bin/memory-pre-turn-harness.mjs --dir .durable-memory');
+  process.exit(2);
+}
+const records = readEventLog(path.join(dir, 'events.jsonl'));
+const dev = { activity: '开发', topic: '技术' };
+const run = { activity: '跑团', topic: '剧情' };
+const controller = new PreTurnController({
+  records,
+  gate: new MemoryLoadState({ loadedFacets: dev, loadedAtTurn: 1490 }),
+});
+const messages = [
+  { text: '我们先写文档', role: 'user', facets: dev, eventSlots: { activity: '开发', topic: '技术', location: null }, confidence: 0.9 },
+  { text: '我们现在开始跑团吧', role: 'user', facets: run, eventSlots: { activity: '跑团', topic: '剧情', location: '灯室' }, confidence: 0.9 },
+  { text: '我推门进灯室', role: 'user', facets: run, eventSlots: { activity: '跑团', topic: '剧情', location: '灯室' }, confidence: 0.9 },
+  { text: 'Coo：灯室见', role: 'coo', facets: run, eventSlots: { activity: '跑团', topic: '剧情', location: '钟楼' }, confidence: 0.9 },
+  { text: '规则怎么写', role: 'user', facets: dev, eventSlots: { activity: '开发', topic: '规则', location: null }, confidence: 0.9 },
+  { text: '上次跑团怎么样了', role: 'user', facets: run, eventSlots: { activity: '跑团', topic: '剧情', location: '灯室' }, confidence: 0.9 },
+  { text: '开始跑团', role: 'assistant', facets: run, eventSlots: { activity: '跑团', topic: '剧情', location: '灯室' }, confidence: 0.9 },
+  { text: '继续', role: 'user', facets: run, eventSlots: { location: 42 }, confidence: 0.9 },
+];
+const rows = messages.map((message, index) => {
+  const result = controller.step({ ...message, nowTurn: 1500 + index });
+  return {
+    text: message.text,
+    role: message.role,
+    action: result.action,
+    reason: result.reason,
+    boundaryScore: result.boundaryScore,
+    eventId: result.eventId,
+    eventError: result.eventError ?? null,
+    candidateTurn: result.candidateTurn,
+    segmentTurns: result.segment?.turns ?? 0,
+    telemetry: result.telemetry,
+  };
+});
+const summary = {
+  messages: rows.length,
+  loads: rows.filter((row) => row.action === 'load').length,
+  hints: rows.filter((row) => row.action === 'hint').length,
+  none: rows.filter((row) => row.action === 'none').length,
+  eventErrors: rows.filter((row) => row.eventError !== null).length,
+};
+const output = { dir, summary, rows };
+fs.writeFileSync(path.join(dir, 'PRE-TURN-HARNESS.json'), JSON.stringify(output, null, 2));
+console.log(JSON.stringify(output, null, 2));

package/bin/memory-query.mjs

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { readEventLog } from '../src/memory/event-log.mjs';
+import { BM25Index } from '../src/memory/bm25.mjs';
+import { VectorIndex } from '../src/memory/vector-index.mjs';
+import { buildPlanner, summaryIndex } from '../src/memory/planner.mjs';
+import { embedTexts } from '../src/facets/embedding.mjs';
+
+const args = process.argv.slice(2);
+const argOf = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+};
+const dir = argOf('--dir');
+const query = argOf('--query');
+const model = argOf('--model');
+if (!dir || !query) {
+  console.error('usage: node bin/memory-query.mjs --dir .durable-memory --query "..." [--model ...]');
+  process.exit(2);
+}
+const records = readEventLog(path.join(dir, 'events.jsonl'));
+const bm25 = BM25Index.fromJSON(JSON.parse(fs.readFileSync(path.join(dir, 'bm25.json'), 'utf8')));
+const vectors = VectorIndex.fromJSON(JSON.parse(fs.readFileSync(path.join(dir, 'vectors.json'), 'utf8')));
+const tree = JSON.parse(fs.readFileSync(path.join(dir, 'summary-tree.json'), 'utf8'));
+const [queryVector] = await embedTexts([query], model);
+const planner = buildPlanner({
+  records,
+  bm25,
+  vectorIndex: vectors,
+  summaryBm25: summaryIndex(tree),
+});
+const result = planner.query(query, { queryVector, topK: 10 });
+console.log(JSON.stringify({
+  query: result.query,
+  layers: result.layers,
+  facet: result.facet,
+  results: result.fused,
+}, null, 2));

package/bin/memory-replay-hints.mjs

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+/**
+ * Prequential hint replay: turn 1 -> end.
+ * At each turn, only prior turns are visible; if the current text mentions an
+ * alias, ask buildLoadHint and record every popup.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { readEventLog } from '../src/memory/event-log.mjs';
+import { buildLoadHint } from '../src/facets/panel.mjs';
+import { DEFAULT_ALIASES } from '../src/facets/schema.mjs';
+
+const args = process.argv.slice(2);
+const argOf = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+};
+const dir = argOf('--dir');
+if (!dir) {
+  console.error('usage: node bin/memory-replay-hints.mjs --dir .durable-memory');
+  process.exit(2);
+}
+const records = readEventLog(path.join(dir, 'events.jsonl'));
+const aliases = Object.keys(DEFAULT_ALIASES).sort((a, b) => b.length - a.length);
+const hints = [];
+for (let index = 0; index < records.length; index += 1) {
+  const current = records[index];
+  const visible = records.slice(0, index);
+  const entries = visible.map((record) => ({
+    turn: record.turn,
+    seqStart: record.seqStart,
+    seqEnd: record.seqEnd,
+    facets: record.facets,
+    unknown: false,
+  }));
+  const mentioned = aliases.filter((alias) => current.text.includes(alias));
+  for (const alias of mentioned) {
+    const hint = buildLoadHint(entries, {
+      query: alias,
+      currentTurn: current.turn,
+      recentTurns: 20,
+      minScore: 0.2,
+    });
+    if (hint === null) continue;
+    const turns = new Set();
+    let chars = 0;
+    for (const range of hint.ranges) {
+      for (const record of visible) {
+        if (record.seqStart >= range.seqStart && record.seqEnd <= range.seqEnd) {
+          turns.add(record.turn);
+          chars += record.text.length;
+        }
+      }
+    }
+    hints.push({
+      turn: current.turn,
+      alias,
+      text: hint.text,
+      topScore: hint.top.score,
+      rangeCount: hint.ranges.length,
+      rangeTurns: turns.size,
+      chars,
+      ranges: hint.ranges.map((range) => ({
+        seqStart: range.seqStart,
+        seqEnd: range.seqEnd,
+        turns: range.turns,
+        lastTurn: range.lastTurn,
+      })),
+      snippet: current.text.slice(0, 100).replace(/\s+/g, ' '),
+    });
+  }
+}
+const summary = {
+  records: records.length,
+  hints: hints.length,
+  byAlias: Object.fromEntries([...new Set(hints.map((hint) => hint.alias))].map((alias) => [alias, hints.filter((hint) => hint.alias === alias).length])),
+  futureLeaks: hints.filter((hint) => hint.ranges.some((range) => range.lastTurn >= hint.turn)).length,
+  large: hints.filter((hint) => hint.rangeTurns > 50 || hint.chars > 10000).length,
+  maxTurns: Math.max(0, ...hints.map((hint) => hint.rangeTurns)),
+  maxChars: Math.max(0, ...hints.map((hint) => hint.chars)),
+};
+const output = { dir, summary, hints };
+fs.writeFileSync(path.join(dir, 'REPLAY-HINTS.json'), JSON.stringify(output, null, 2));
+console.log(JSON.stringify(summary, null, 2));

package/bin/memory-scale.mjs

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+/**
+ * Scale benchmark for the exact durable-memory layers.
+ * Replicates the real 1,462-turn copy to 10k/50k for latency/memory testing.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { buildEventLog } from '../src/memory/event-log.mjs';
+import { BM25Index } from '../src/memory/bm25.mjs';
+import { VectorIndex } from '../src/memory/vector-index.mjs';
+
+const args = process.argv.slice(2);
+const argOf = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+};
+const dir = argOf('--dir') ?? 'C:/Users/35794/Documents/DeepSeek\'s Sandbox/coopanion-continuity/backups/continuity-tags-20261031/durable-memory/build-a';
+const source = fs.readFileSync(path.join(dir, 'events.jsonl'), 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+const embeddings = JSON.parse(fs.readFileSync('C:/Users/35794/Documents/DeepSeek\'s Sandbox/coopanion-continuity/backups/continuity-tags-20261031/online400/embeddings-1500.json', 'utf8'));
+const vectorBySourceTurn = new Map(embeddings.map((row) => [row.turn, row.vector]));
+const sizes = [10000, 50000];
+const out = [];
+for (const size of sizes) {
+  const rows = [];
+  const vectorMap = new Map();
+  for (let index = 0; index < size; index += 1) {
+    const base = source[index % source.length];
+    const turn = 100000 + index;
+    rows.push({ ...base, turn, seqStart: 1000000 + index, seqEnd: 1000000 + index });
+    vectorMap.set(turn, vectorBySourceTurn.get(base.turn));
+  }
+  const buildStart = performance.now();
+  const records = buildEventLog(rows);
+  const bm25 = new BM25Index().build(records);
+  const vectors = new VectorIndex().build(records, vectorMap);
+  const buildMs = performance.now() - buildStart;
+  const queries = Array.from({ length: 100 }, (_, index) => source[index % source.length]);
+  const vectorStart = performance.now();
+  for (const row of queries) vectors.search(vectorBySourceTurn.get(row.turn), { topK: 10 });
+  const vectorMs = performance.now() - vectorStart;
+  const bm25Start = performance.now();
+  for (const row of queries) bm25.search(row.text, { topK: 10 });
+  const bm25Ms = performance.now() - bm25Start;
+  const mem = process.memoryUsage();
+  out.push({
+    size,
+    buildMs: Math.round(buildMs),
+    vector100Ms: Math.round(vectorMs),
+    vectorMsPerQuery: +(vectorMs / queries.length).toFixed(2),
+    bm25100Ms: Math.round(bm25Ms),
+    bm25MsPerQuery: +(bm25Ms / queries.length).toFixed(2),
+    heapMB: +(mem.heapUsed / 1048576).toFixed(1),
+    rssMB: +(mem.rss / 1048576).toFixed(1),
+  });
+}
+fs.writeFileSync(path.join(dir, 'SCALE-DURABLE.json'), JSON.stringify(out, null, 2));
+console.log(JSON.stringify(out, null, 2));