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

package/src/memory/summary-index.mjs

@@ -0,0 +1,335 @@
+/**
+ * Summary index for Continuity.
+ *
+ * This is the middle layer between gist pointers and raw session text:
+ *   gist        short pointer (existing)
+ *   summary     structured text over a seq range (this index)
+ *   raw         session log, source of truth
+ *
+ * Phase 0/1 is read-only/index-only: it imports existing compaction/summary
+ * events (native checkpoints and Continuity gists) and plans missing windows.
+ * It never rewrites or deletes raw events.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+
+export const SUMMARY_INDEX_VERSION = 1;
+export const DEFAULT_WINDOW_TOKENS = 40_000;
+
+const GIST_PREFIX = /^\[(?:thread|gist)\b/i;
+
+function numberOrNull(value) {
+  const n = Number(value);
+  return Number.isInteger(n) ? n : null;
+}
+
+export function summaryText(event) {
+  const summary = event?.data?.summary;
+  if (Array.isArray(summary)) {
+    return summary
+      .map((block) => (block && typeof block === 'object' && typeof block.text === 'string' ? block.text : ''))
+      .join('');
+  }
+  return typeof summary === 'string' ? summary : '';
+}
+
+function turnMarkers(events) {
+  return (Array.isArray(events) ? events : [])
+    .filter((event) => event?.type === 'turn/start' && Number.isInteger(Number(event?.data?.turn)))
+    .map((event) => ({ seq: Number(event.seq), turn: Number(event.data.turn) }))
+    .sort((a, b) => a.seq - b.seq);
+}
+
+function turnAt(markers, seq) {
+  let found = null;
+  for (const marker of markers) {
+    if (marker.seq <= seq) found = marker.turn;
+    else break;
+  }
+  return found;
+}
+
+function textTokens(text) {
+  return Math.max(1, Math.ceil(String(text ?? '').length / 4));
+}
+
+function parseThreads(text) {
+  const out = new Set();
+  const pattern = /\b(?:T|thread)=([A-Za-z0-9_-]+)/g;
+  let match;
+  while ((match = pattern.exec(String(text ?? ''))) !== null) out.add(match[1]);
+  return [...out];
+}
+
+function recordFromEvent(event, markers) {
+  const text = summaryText(event).trim();
+  if (!text) return null;
+  const start = numberOrNull(event?.data?.shadowedRange?.start);
+  const end = numberOrNull(event?.data?.shadowedRange?.end);
+  if (start === null || end === null) return null;
+  const fromSeq = Math.min(start, end);
+  const toSeq = Math.max(start, end);
+  const kind = GIST_PREFIX.test(text) ? 'gist' : 'checkpoint';
+  return {
+    id: `s-${fromSeq}-${toSeq}`,
+    kind,
+    fromSeq,
+    toSeq,
+    fromTurn: turnAt(markers, fromSeq),
+    toTurn: turnAt(markers, toSeq),
+    threads: parseThreads(text),
+    chars: text.length,
+    approxTokens: textTokens(text),
+    sourceTokens: numberOrNull(event?.data?.shadowedTokenCount),
+    sourceHash: createHash('sha256').update(`${fromSeq}:${toSeq}:${text}`, 'utf8').digest('hex'),
+    text,
+    status: 'ready',
+  };
+}
+
+function mergeRanges(records) {
+  const ranges = records
+    .map((record) => ({ start: record.fromSeq, end: record.toSeq }))
+    .sort((a, b) => a.start - b.start || a.end - b.end);
+  const merged = [];
+  for (const range of ranges) {
+    const last = merged.at(-1);
+    if (last && range.start <= last.end + 1) last.end = Math.max(last.end, range.end);
+    else merged.push({ ...range });
+  }
+  return merged;
+}
+
+function visibleText(event) {
+  if (!event || (event.type !== 'user/message' && event.type !== 'assistant/message')) return '';
+  const content = event.type === 'assistant/message'
+    ? event?.data?.message?.content
+    : event?.data?.content;
+  let out = '';
+  for (const block of content ?? []) {
+    if (block && block.type === 'text') out += block.text ?? '';
+  }
+  return out;
+}
+
+function estimateGapTokens(events, start, end) {
+  let tokens = 0;
+  for (const event of events) {
+    const seq = Number(event?.seq);
+    if (!Number.isInteger(seq) || seq < start || seq > end) continue;
+    tokens += textTokens(visibleText(event));
+  }
+  return tokens;
+}
+
+/**
+ * Build a summary index from one session's raw events.
+ * @param {{sessionId: string, events: object[], windowTokens?: number}} input
+ */
+export function buildSummaryIndex({
+  sessionId,
+  events,
+  windowTokens = DEFAULT_WINDOW_TOKENS,
+  bootstrapRanges = [],
+  windowRanges = [],
+  windowRecords = [],
+}) {
+  const list = Array.isArray(events) ? events : [];
+  const markers = turnMarkers(list);
+  const records = list
+    .filter((event) => event?.type === 'compaction/summary')
+    .map((event) => recordFromEvent(event, markers))
+    .filter(Boolean)
+    .sort((a, b) => a.fromSeq - b.fromSeq || a.toSeq - b.toSeq);
+  const unique = [];
+  const seen = new Set();
+  for (const record of records) {
+    const key = `${record.fromSeq}:${record.toSeq}:${record.sourceHash}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(record);
+  }
+  const boot = (Array.isArray(bootstrapRanges) ? bootstrapRanges : [])
+    .map((range) => ({
+      fromSeq: Number(range?.fromSeq ?? range?.start),
+      toSeq: Number(range?.toSeq ?? range?.end),
+      tokens: Number(range?.tokens ?? 0),
+      carrierSeq: Number(range?.carrierSeq ?? 0),
+      at: typeof range?.at === 'string' ? range.at : null,
+      kind: 'bootstrap-replace',
+    }))
+    .filter((range) => Number.isInteger(range.fromSeq) && Number.isInteger(range.toSeq))
+    .map((range) => (range.fromSeq <= range.toSeq ? range : { ...range, fromSeq: range.toSeq, toSeq: range.fromSeq }))
+    .sort((a, b) => a.fromSeq - b.fromSeq || a.toSeq - b.toSeq);
+  const windows = (Array.isArray(windowRanges) ? windowRanges : [])
+    .map((range) => ({
+      fromSeq: Number(range?.fromSeq ?? range?.start),
+      toSeq: Number(range?.toSeq ?? range?.end),
+      tokens: Number(range?.tokens ?? 0),
+      hash: typeof range?.hash === 'string' ? range.hash : null,
+      at: typeof range?.at === 'string' ? range.at : null,
+      kind: 'window-extractive',
+    }))
+    .filter((range) => Number.isInteger(range.fromSeq) && Number.isInteger(range.toSeq))
+    .map((range) => (range.fromSeq <= range.toSeq ? range : { ...range, fromSeq: range.toSeq, toSeq: range.fromSeq }))
+    .sort((a, b) => a.fromSeq - b.fromSeq || a.toSeq - b.toSeq);
+  const windowRecordList = (Array.isArray(windowRecords) ? windowRecords : [])
+    .map((summary) => ({
+      id: `window-${Number(summary?.fromSeq)}-${Number(summary?.toSeq)}`,
+      kind: 'window-extractive',
+      quality: 'extractive',
+      fromSeq: Number(summary?.fromSeq),
+      toSeq: Number(summary?.toSeq),
+      text: String(summary?.text ?? ''),
+      sourceHash: String(summary?.hash ?? ''),
+      sourceTokens: Number(summary?.approxTokens ?? 0),
+      fromTurn: null,
+      toTurn: null,
+    }))
+    .filter((record) => Number.isInteger(record.fromSeq) && Number.isInteger(record.toSeq) && record.text.length > 0);
+
+  const seqs = list.map((event) => Number(event?.seq)).filter(Number.isInteger);
+  const minSeq = seqs.length ? Math.min(...seqs) : null;
+  const maxSeq = seqs.length ? Math.max(...seqs) : null;
+  const ranges = mergeRanges([...unique, ...boot, ...windows]);
+  const gaps = [];
+  if (minSeq !== null && maxSeq !== null) {
+    let cursor = minSeq;
+    for (const range of ranges) {
+      if (range.start > cursor) gaps.push({ start: cursor, end: range.start - 1 });
+      cursor = Math.max(cursor, range.end + 1);
+    }
+    if (cursor <= maxSeq) gaps.push({ start: cursor, end: maxSeq });
+  }
+  const pendingWindows = gaps
+    .map((gap) => ({
+      ...gap,
+      approxTokens: estimateGapTokens(list, gap.start, gap.end),
+    }))
+    .filter((gap) => gap.approxTokens >= windowTokens)
+    .map((gap) => ({
+      id: `pending-${gap.start}-${gap.end}`,
+      fromSeq: gap.start,
+      toSeq: gap.end,
+      approxTokens: gap.approxTokens,
+      status: 'missing',
+    }));
+
+  const sourceTokens = ranges.reduce((sum, range) => sum + estimateGapTokens(list, range.start, range.end), 0);
+  const summaryEvents = list.filter((event) => event?.type === 'compaction/summary');
+  const maxSummarySeq = summaryEvents.reduce((max, event) => {
+    const seq = Number(event?.seq);
+    return Number.isInteger(seq) && seq > max ? seq : max;
+  }, -1);
+  const coveredThroughSeq = [...unique, ...boot, ...windows].reduce((max, record) => (record.toSeq > max ? record.toSeq : max), -1);
+  const latestSummaryAt = summaryEvents.reduce((latest, event) => {
+    const time = Number(event?.time);
+    return Number.isFinite(time) && time > latest ? time : latest;
+  }, 0);
+  return {
+    version: SUMMARY_INDEX_VERSION,
+    sessionId: String(sessionId ?? ''),
+    generatedAt: new Date().toISOString(),
+    windowTokens,
+    maxSummarySeq,
+    coveredThroughSeq,
+    latestSummaryAt: latestSummaryAt > 0 ? new Date(latestSummaryAt).toISOString() : null,
+    records: [...unique, ...windowRecordList],
+    bootstrapRanges: boot,
+    windowRanges: windows,
+    pendingWindows,
+    coverage: {
+      minSeq,
+      maxSeq,
+      records: unique.length,
+      modelRecords: unique.length,
+      ready: unique.length,
+      windows: windows.length,
+      pending: pendingWindows.length,
+      bootstrap: boot.length,
+      ranges: ranges.length,
+      sourceTokensBasis: 'dedup-merged-ranges',
+      sourceTokens,
+      sourceTokensSum: unique.reduce((sum, record) => sum + (record.sourceTokens ?? 0), 0),
+    },
+  };
+}
+
+export function summaryIndexPath(sessionDir) {
+  return path.join(sessionDir, 'summaries', 'index.json');
+}
+
+/** Compare the summary index against the newest live summary event. */
+export function summaryIndexStaleness(index, records, { latestSummarySeq = null } = {}) {
+  const fallbackSeq = (Array.isArray(records) ? records : [])
+    .map((record) => Number(record?.seqEnd ?? record?.seq))
+    .filter(Number.isInteger)
+    .reduce((max, seq) => (seq > max ? seq : max), -1);
+  const latestSeq = Number.isInteger(latestSummarySeq) ? latestSummarySeq : fallbackSeq;
+  const rawMax = Number(index?.maxSummarySeq);
+  const hasMax = Number.isInteger(rawMax) && rawMax >= 0;
+  const maxSummarySeq = hasMax ? rawMax : null;
+  const stale = !hasMax || !Number.isInteger(latestSeq) || latestSeq !== maxSummarySeq;
+  const staleBy = hasMax && Number.isInteger(latestSeq) ? latestSeq - maxSummarySeq : null;
+  return {
+    stale,
+    staleBy,
+    latestSeq,
+    maxSummarySeq,
+    latestSummaryAt: index?.latestSummaryAt ?? null,
+  };
+}
+
+/** Local, read-only summary lookup. This is the seed for recall.summaryHits. */
+export function querySummaryIndex(index, query, { limit = 5 } = {}) {
+  const q = String(query ?? '').normalize('NFKC').toLowerCase();
+  if (!q) return { total: 0, hits: [] };
+  const qChars = [...q];
+  const cjkQuery = /[\u3400-\u9fff]/.test(q);
+  const records = Array.isArray(index?.records) ? index.records : [];
+  const scored = [];
+  for (const record of records) {
+    const text = String(record.text ?? '').normalize('NFKC').toLowerCase();
+    if (!text) continue;
+    let score = 0;
+    const exact = text.includes(q);
+    if (exact) score += 100;
+    if (cjkQuery && qChars.length >= 2) {
+      const covered = qChars.filter((ch) => text.includes(ch)).length;
+      if (covered === qChars.length) score += 5;
+    }
+    if (score > 0) scored.push({ record, score, exact });
+  }
+  scored.sort((a, b) => b.score - a.score || b.record.toSeq - a.record.toSeq);
+  return {
+    total: scored.length,
+    hits: scored.slice(0, limit).map(({ record, score, exact }) => ({
+      id: record.id,
+      kind: record.kind,
+      quality: record.quality ?? null,
+      fromSeq: record.fromSeq,
+      toSeq: record.toSeq,
+      fromTurn: record.fromTurn,
+      toTurn: record.toTurn,
+      threads: record.threads,
+      approxTokens: record.approxTokens,
+      score: Number(score.toFixed(2)),
+      exact,
+      excerpt: String(record.text ?? '').slice(0, 500),
+    })),
+  };
+}
+
+export function writeSummaryIndex(sessionDir, index) {
+  const file = summaryIndexPath(sessionDir);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.tmp-${process.pid}`;
+  fs.writeFileSync(tmp, JSON.stringify(index, null, 2), 'utf8');
+  fs.renameSync(tmp, file);
+  return file;
+}
+
+export function readSummaryIndex(file) {
+  return JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, ''));
+}

package/src/memory/summary-tree.mjs

@@ -0,0 +1,110 @@
+/**
+ * Deterministic, versioned extractive summary tree.
+ * Leaves are turns; segments and chapters only point at children and seq ranges.
+ * No LLM is used here, so rebuilding is byte-stable.
+ */
+import { createHash } from 'node:crypto';
+
+function sha256(text) {
+  return createHash('sha256').update(text, 'utf8').digest('hex');
+}
+
+function clip(text, max) {
+  const clean = String(text ?? '').replace(/\s+/g, ' ').trim();
+  return clean.length <= max ? clean : `${clean.slice(0, max)}…`;
+}
+
+function nodeId(level, index) {
+  return `${level}-${String(index + 1).padStart(5, '0')}`;
+}
+
+export function buildSummaryTree(records, {
+  segmentSize = 8,
+  chapterSize = 8,
+} = {}) {
+  const leaves = records.map((record, index) => ({
+    id: nodeId('turn', index),
+    level: 'turn',
+    parentId: null,
+    childIds: [],
+    turn: record.turn,
+    seqStart: record.seqStart,
+    seqEnd: record.seqEnd,
+    summary: clip(record.text, 280),
+    sourceHash: record.hash,
+  }));
+
+  const segments = [];
+  for (let start = 0; start < leaves.length; start += segmentSize) {
+    const children = leaves.slice(start, start + segmentSize);
+    const id = nodeId('segment', segments.length);
+    const summary = clip(children.map((child) => child.summary).join(' / '), 700);
+    const node = {
+      id,
+      level: 'segment',
+      parentId: null,
+      childIds: children.map((child) => child.id),
+      seqStart: children[0].seqStart,
+      seqEnd: children[children.length - 1].seqEnd,
+      firstTurn: children[0].turn,
+      lastTurn: children[children.length - 1].turn,
+      summary,
+      sourceHash: sha256(children.map((child) => child.sourceHash).join('')),
+    };
+    for (const child of children) child.parentId = id;
+    segments.push(node);
+  }
+
+  const chapters = [];
+  for (let start = 0; start < segments.length; start += chapterSize) {
+    const children = segments.slice(start, start + chapterSize);
+    const id = nodeId('chapter', chapters.length);
+    const summary = clip(children.map((child) => child.summary).join(' / '), 1200);
+    const node = {
+      id,
+      level: 'chapter',
+      parentId: null,
+      childIds: children.map((child) => child.id),
+      seqStart: children[0].seqStart,
+      seqEnd: children[children.length - 1].seqEnd,
+      firstTurn: children[0].firstTurn,
+      lastTurn: children[children.length - 1].lastTurn,
+      summary,
+      sourceHash: sha256(children.map((child) => child.sourceHash).join('')),
+    };
+    for (const child of children) child.parentId = id;
+    chapters.push(node);
+  }
+
+  const nodes = [...leaves, ...segments, ...chapters];
+  const treeRootHash = sha256(nodes.map((node) => node.sourceHash).join(''));
+  return {
+    schema: 1,
+    version: 1,
+    segmentSize,
+    chapterSize,
+    nodeCount: nodes.length,
+    levels: { turn: leaves.length, segment: segments.length, chapter: chapters.length },
+    treeRootHash,
+    nodes,
+  };
+}
+
+export function verifySummaryTree(tree) {
+  const byId = new Map(tree.nodes.map((node) => [node.id, node]));
+  const errors = [];
+  for (const node of tree.nodes) {
+    for (const childId of node.childIds) {
+      const child = byId.get(childId);
+      if (child === undefined) {
+        errors.push({ id: node.id, reason: 'missing-child', childId });
+        continue;
+      }
+      if (child.parentId !== node.id) errors.push({ id: child.id, reason: 'parent-mismatch' });
+      if (child.seqStart < node.seqStart || child.seqEnd > node.seqEnd) {
+        errors.push({ id: child.id, reason: 'child-outside-parent' });
+      }
+    }
+  }
+  return { ok: errors.length === 0, errors };
+}

package/src/memory/term-extractor.mjs

@@ -0,0 +1,44 @@
+/**
+ * Term candidate extraction.
+ * Extracts definitional names, quoted names, and "X的规则/设定" patterns.
+ * Source weighting is applied later by the referent ledger.
+ */
+
+const DEFINITION = /(?:叫做|叫|名为|称为|名字是|称作)\s*[《「“"]?([\u4e00-\u9fffA-Za-z0-9_·-]{2,12})[》」”"]?/gu;
+const QUOTED = /[《「“"]([^》」”"\n]{2,16})[》」”"]/gu;
+const BEFORE_RULE = /([\u4e00-\u9fffA-Za-z0-9_·-]{2,10})(?:的)?(?:规则|设定|世界观|背景|系统)/gu;
+const STOP = /^(什么|这个|那个|我们|你们|他们|最近|现在|已经|可以|需要|因为|所以|问题|东西|地方|名字|标签|备份|一个|一种|一下|这些|那些)$/u;
+
+export function normalizeTerm(value) {
+  return String(value ?? '')
+    .replace(/[《》「」“”"'`]/g, '')
+    .replace(/[，。！？、；：\s]+$/g, '')
+    .trim();
+}
+
+function validTerm(term) {
+  if (term.length < 2 || term.length > 12) return false;
+  if (STOP.test(term)) return false;
+  if (/^[0-9]+$/u.test(term)) return false;
+  if (/[，。！？、；：]/u.test(term)) return false;
+  return true;
+}
+
+export function extractTerms(text, { max = 8 } = {}) {
+  const source = String(text ?? '');
+  const found = [];
+  const add = (value, kind, index) => {
+    const term = normalizeTerm(value);
+    if (!validTerm(term)) return;
+    if (found.some((item) => item.term === term)) return;
+    found.push({ term, kind, index });
+  };
+  for (const regex of [DEFINITION, QUOTED, BEFORE_RULE]) {
+    regex.lastIndex = 0;
+    let match;
+    while ((match = regex.exec(source)) !== null) {
+      add(match[1], regex === DEFINITION ? 'definition' : regex === QUOTED ? 'quoted' : 'mention', match.index);
+    }
+  }
+  return found.sort((a, b) => a.index - b.index).slice(0, max);
+}

package/src/memory/tokenize.mjs

@@ -0,0 +1,9 @@
+/** Shared tokenizer for BM25. */
+export function tokenize(text) {
+  const raw = String(text ?? '').toLowerCase();
+  const words = raw.match(/[a-z0-9_]+/g) ?? [];
+  const chinese = [...raw.replace(/[^\u4e00-\u9fff]/g, '')];
+  const bigrams = [];
+  for (let i = 0; i + 1 < chinese.length; i += 1) bigrams.push(chinese[i] + chinese[i + 1]);
+  return [...words, ...bigrams];
+}

package/src/memory/vector-index.mjs

@@ -0,0 +1,54 @@
+/**
+ * Brute-force vector index for the durable-memory prototype.
+ * At 1,462 turns this is exact and cheap; HNSW can replace it later.
+ */
+import fs from 'node:fs';
+
+function cosine(a, b) {
+  let dot = 0;
+  for (let i = 0; i < a.length; i += 1) dot += a[i] * b[i];
+  return dot;
+}
+
+export class VectorIndex {
+  constructor() {
+    this.docs = [];
+  }
+
+  build(records, vectorsByTurn) {
+    this.docs = [];
+    for (const record of records) {
+      const vector = vectorsByTurn.get(record.turn);
+      if (vector === undefined) continue;
+      this.docs.push({
+        turn: record.turn,
+        seqStart: record.seqStart,
+        seqEnd: record.seqEnd,
+        vector,
+      });
+    }
+    return this;
+  }
+
+  search(vector, { topK = 20 } = {}) {
+    return this.docs
+      .map((doc) => ({ ...doc, score: cosine(vector, doc.vector) }))
+      .sort((a, b) => b.score - a.score)
+      .slice(0, topK);
+  }
+
+  toJSON() {
+    return { docs: this.docs };
+  }
+
+  static fromJSON(raw) {
+    const index = new VectorIndex();
+    index.docs = raw.docs;
+    return index;
+  }
+}
+
+export function loadEmbeddings(file) {
+  const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+  return new Map(data.map((row) => [row.turn, row.vector]));
+}

package/src/memory/window-summary.mjs

@@ -0,0 +1,133 @@
+/**
+ * Deterministic window summary.
+ *
+ * This is the fallback generator for a pending archive window when no
+ * compaction/checkpoint summary exists. It is deliberately structural, not a
+ * replacement for an LLM summary: it preserves who said/did what and where the
+ * raw seqs are, so a later model pass can replace the body without changing the
+ * carrier contract.
+ */
+import { createHash } from 'node:crypto';
+
+const DEFAULT_MAX_TOKENS = 800;
+const CHARS_PER_TOKEN = 4;
+const INJECTED = /^(?:\[(?:continuity:|追忆|抽取|工作线|标签|规则|规矩|习惯|技能|归位|候选|存\?|闸|回正|学习|记忆)|<system-reminder>|Current runtime context|Time sampled while preparing)/i;
+const PEER = /^\[(?:创|peer)\]/i;
+
+function textOf(event) {
+  const data = event?.data ?? {};
+  const blocks = data?.message?.content ?? data?.content ?? [];
+  if (!Array.isArray(blocks)) return '';
+  return blocks
+    .filter((block) => block && typeof block === 'object' && block.type === 'text')
+    .map((block) => String(block.text ?? ''))
+    .join('\n');
+}
+
+function oneLine(text, maxChars) {
+  const clean = String(text ?? '').replace(/\s+/g, ' ').trim();
+  if (clean.length <= maxChars) return clean;
+  return `${clean.slice(0, maxChars).replace(/\s+\S*$/, '')}…`;
+}
+
+function toolNames(event) {
+  const data = event?.data ?? {};
+  const name = data?.name ?? data?.toolName ?? data?.message?.name;
+  return typeof name === 'string' && name.length > 0 ? name : null;
+}
+
+export function buildWindowSummary({
+  events,
+  fromSeq,
+  toSeq,
+  maxTokens = DEFAULT_MAX_TOKENS,
+}) {
+  const from = Math.min(Number(fromSeq), Number(toSeq));
+  const to = Math.max(Number(fromSeq), Number(toSeq));
+  const list = (Array.isArray(events) ? events : [])
+    .filter((event) => {
+      const seq = Number(event?.seq);
+      return Number.isInteger(seq) && seq >= from && seq <= to;
+    })
+    .sort((a, b) => Number(a.seq) - Number(b.seq));
+
+  const users = [];
+  const peers = [];
+  const assistants = [];
+  const tools = [];
+  for (const event of list) {
+    if (event?.type === 'user/message') {
+      const text = textOf(event).trim();
+      if (text.length === 0 || INJECTED.test(text)) continue;
+      if (PEER.test(text)) peers.push(event);
+      else users.push(event);
+    } else if (event?.type === 'assistant/message') {
+      if (textOf(event).trim().length > 0) assistants.push(event);
+    } else if (event?.type === 'tool/call') {
+      const name = toolNames(event);
+      if (name !== null) tools.push(name);
+    }
+  }
+
+  const lines = [];
+  lines.push(`## 窗口 seq ${from}-${to}`);
+  lines.push(`事件 ${list.length} · 用户 ${users.length} · 同伴 ${peers.length} · 助手 ${assistants.length} · 工具 ${tools.length}`);
+
+  const pickedUsers = users.length <= 4
+    ? users
+    : [...users.slice(0, 2), ...users.slice(-2)];
+  const pickedPeers = peers.length <= 4
+    ? peers
+    : [...peers.slice(0, 2), ...peers.slice(-2)];
+  const pickedAssistants = assistants.length <= 4
+    ? assistants
+    : [...assistants.slice(0, 2), ...assistants.slice(-2)];
+
+  if (pickedUsers.length > 0) {
+    lines.push('## 用户');
+    for (const event of pickedUsers) {
+      const text = oneLine(textOf(event), 220);
+      if (text.length > 0) lines.push(`- seq ${event.seq}: ${text}`);
+    }
+  }
+  if (pickedPeers.length > 0) {
+    lines.push('## 同伴');
+    for (const event of pickedPeers) {
+      const text = oneLine(textOf(event), 220);
+      if (text.length > 0) lines.push(`- (peer) seq ${event.seq}: ${text}`);
+    }
+  }
+  if (pickedAssistants.length > 0) {
+    lines.push('## 助手');
+    for (const event of pickedAssistants) {
+      const text = oneLine(textOf(event), 220);
+      if (text.length > 0) lines.push(`- seq ${event.seq}: ${text}`);
+    }
+  }
+  const uniqueTools = [...new Set(tools)];
+  if (uniqueTools.length > 0) {
+    lines.push('## 工具');
+    lines.push(uniqueTools.slice(0, 12).join(', '));
+  }
+  lines.push('## 指针');
+  lines.push(`本窗口 raw 首尾：${from}..${to}；细节按 seq 回 session_log 取。`);
+
+  let text = lines.join('\n');
+  const capChars = Math.max(400, maxTokens) * CHARS_PER_TOKEN;
+  if (text.length > capChars) {
+    text = `${text.slice(0, capChars).replace(/\s+\S*$/, '')}…`;
+  }
+  const approxTokens = Math.ceil(text.length / CHARS_PER_TOKEN);
+  return {
+    fromSeq: from,
+    toSeq: to,
+    text,
+    chars: text.length,
+    approxTokens,
+    hash: createHash('sha256').update(text, 'utf8').digest('hex').slice(0, 16),
+    kind: 'window-extractive',
+    quality: list.length > 1000 && approxTokens < 400 ? 'extractive-thin' : 'extractive',
+  };
+}
+
+export default buildWindowSummary;