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

package/src/memory/bc-index-updater.mjs

@@ -0,0 +1,404 @@
+/**
+ * Incremental B-index updater.
+ *
+ * One pointer record per completed turn. The raw text stays in the session log;
+ * this module only writes generic concepts, scores, keywords, and seq pointers.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { embedTexts } from '../facets/embedding.mjs';
+import { createBLabeler, LABELER_VERSION } from './bc-label.mjs';
+import { extractKeywords, makeRecord } from './bc-recall.mjs';
+import { loadIndexJsonl, saveIndexJsonl } from './bc-index.mjs';
+import { loadSpecialKeywords, matchSpecialKeywords } from './special-keywords.mjs';
+import { loadCMapEntries } from './cmap-file.mjs';
+import { buildDf, chatterScore } from './chatter.mjs';
+import { eventText } from '../session-log.mjs';
+
+const INJECTED = /^\[(?:抽取|工作线|标签|规则|习惯|技能|归位|候选|存\?|闸|回正|学习|追忆|记忆|continuity:[a-z-]+)\]/;
+const MACHINE = /^(?:Current runtime context|Current working directory|Current DSH file policy|Approval prompts|Time sampled)/;
+const BASELINE_WINDOW = 300;
+// 打标阈值：既喂给 labeler，也参与 labelStamp 的计算（改这里等于改依据）
+export const TOPIC_THRESHOLDS = Object.freeze({ topicMinScore: 0.33, centerMin: 0.02, lead: 0.02 });
+
+/**
+ * labelStamp：这一行是"用哪套依据"标的。
+ * stamp = sha256(concepts.md 内容 | 阈值 | LABELER_VERSION)[:12]
+ * 表没变、阈值没变、判定逻辑没变 → stamp 不变 → 增量迁移时这行不需要重标。
+ */
+export function computeLabelStamp({ conceptsText = '', thresholds = TOPIC_THRESHOLDS, labelerVersion = LABELER_VERSION } = {}) {
+  return createHash('sha256')
+    .update(`${conceptsText}|${thresholds.topicMinScore}|${thresholds.centerMin}|${thresholds.lead}|${labelerVersion}`)
+    .digest('hex')
+    .slice(0, 12);
+}
+
+function emptyBaseline() {
+  return { version: 2, window: BASELINE_WINDOW, topics: {}, workflows: {} };
+}
+
+function loadBaseline(file) {
+  try {
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf8').replace(/^\uFEFF/, ''));
+    if (parsed && parsed.version === 2 && parsed.topics && parsed.workflows) return parsed;
+    if (parsed && parsed.version === 1 && parsed.samples && typeof parsed.samples === 'object') {
+      return { version: 2, window: BASELINE_WINDOW, topics: parsed.samples, workflows: {} };
+    }
+  } catch { /* first run */ }
+  return emptyBaseline();
+}
+
+function baselineMeans(state, group = 'topics') {
+  const means = {};
+  for (const [concept, samples] of Object.entries(state?.[group] ?? {})) {
+    if (!Array.isArray(samples) || samples.length === 0) continue;
+    means[concept] = samples.reduce((sum, value) => sum + Number(value || 0), 0) / samples.length;
+  }
+  return means;
+}
+
+function baselineGlobalMean(means) {
+  const values = Object.values(means ?? {}).filter((value) => Number.isFinite(value));
+  if (values.length === 0) return null;
+  return values.reduce((sum, value) => sum + value, 0) / values.length;
+}
+
+function updateBaseline(state, scores, group = 'topics') {
+  if (!scores || typeof scores !== 'object') return state;
+  if (!state[group] || typeof state[group] !== 'object') state[group] = {};
+  for (const [concept, score] of Object.entries(scores)) {
+    if (!Number.isFinite(Number(score))) continue;
+    const samples = Array.isArray(state[group][concept]) ? state[group][concept] : [];
+    samples.push(Number(score));
+    if (samples.length > BASELINE_WINDOW) samples.shift();
+    state[group][concept] = samples;
+  }
+  return state;
+}
+
+function saveBaseline(file, state) {
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const temp = `${file}.tmp-${process.pid}`;
+    fs.writeFileSync(temp, JSON.stringify(state), 'utf8');
+    fs.renameSync(temp, file);
+  } catch { /* baseline failure must not block indexing */ }
+}
+
+function isHuman(event) {
+  const source = event?.data?.source ?? event?.source;
+  if (source && typeof source.kind === 'string' && source.kind !== 'user') return false;
+  if (source && source.peer === true) return false;
+  const text = eventText(event, { includeReasoning: false }).trim();
+  return Boolean(text) && !INJECTED.test(text) && !MACHINE.test(text);
+}
+
+function turnsFromEvents(events, afterTurn, afterSeq = -1) {
+  const list = Array.isArray(events) ? events : [];
+  const markers = list
+    .map((event) => ({ seq: Number(event?.seq), turn: Number(event?.data?.turn) }))
+    .filter((item) => Number.isInteger(item.seq) && Number.isInteger(item.turn))
+    .sort((a, b) => a.seq - b.seq);
+  const turnAt = (seq) => {
+    let found = null;
+    for (const marker of markers) {
+      if (marker.seq > seq) break;
+      found = marker.turn;
+    }
+    if (found !== null) return found;
+    const next = markers.find((marker) => marker.seq >= seq);
+    return next?.turn ?? null;
+  };
+  const byTurn = new Map();
+  for (const event of list) {
+    const type = event?.type;
+    if (type !== 'user/message' && type !== 'assistant/message') continue;
+    if (type === 'user/message' && !isHuman(event)) continue;
+    const text = eventText(event, { includeReasoning: false }).trim();
+    if (!text || INJECTED.test(text) || MACHINE.test(text)) continue;
+    const seq = Number(event?.seq);
+    const turn = Number.isInteger(Number(event?.data?.turn))
+      ? Number(event.data.turn)
+      : turnAt(seq);
+    if (!Number.isInteger(turn) || !Number.isInteger(seq)) continue;
+    if (turn <= afterTurn || seq <= afterSeq) continue;
+    const item = byTurn.get(turn) ?? {
+      turn,
+      seqStart: seq,
+      seqEnd: seq,
+      userTexts: [],
+      assistantTexts: [],
+      texts: [],
+    };
+    item.seqStart = Math.min(item.seqStart, seq);
+    item.seqEnd = Math.max(item.seqEnd, seq);
+    if (type === 'user/message') item.userTexts.push(text);
+    else item.assistantTexts.push(text);
+    byTurn.set(turn, item);
+  }
+  return [...byTurn.values()]
+    .map((item) => ({ ...item, texts: [...item.userTexts, ...item.assistantTexts] }))
+    .sort((a, b) => a.turn - b.turn);
+}
+
+export function createIndexUpdater({
+  file,
+  stateFile = null,
+  baselineFile = null,
+  sessionQuery = null,
+  labeler = null,
+  labels = null,
+  kinds = null,
+  keywordsFile = null,
+  cmapFile = null,
+  conceptsFile = null,
+  gate = null,
+  maxPerRun = 8,
+  onError = null,
+  onCost = null,
+} = {}) {
+  let activeLabeler = labeler;
+  let running = false;
+  let warnedMissingCmap = false;
+  // 保存的是 promise 而不是 bool：bool 在"刚结束但尚未置回"的窗口里不可靠
+  let runningPromise = null;
+  // gate 命中时被挡下的行留在这里，下一轮先合并再写（不丢数据）
+  const pendingBySession = new Map();
+
+  const readState = () => {
+    if (stateFile === null) return {};
+    try { return JSON.parse(fs.readFileSync(stateFile, 'utf8').replace(/^\uFEFF/, '')); } catch { return {}; }
+  };
+  const writeState = (value) => {
+    if (stateFile === null) return;
+    try {
+      fs.mkdirSync(path.dirname(stateFile), { recursive: true });
+      fs.writeFileSync(stateFile, JSON.stringify(value, null, 2), 'utf8');
+    } catch { /* state failure must not block indexing */ }
+  };
+  const takePending = (sessionId) => {
+    const rows = pendingBySession.get(sessionId) ?? [];
+    pendingBySession.delete(sessionId);
+    return rows;
+  };
+  const pushPending = (sessionId, rows) => {
+    if (!rows || rows.length === 0) return;
+    const existing = pendingBySession.get(sessionId) ?? [];
+    const byTurn = new Map(existing.map((row) => [row.turn, row]));
+    for (const row of rows) byTurn.set(row.turn, row);
+    pendingBySession.set(sessionId, [...byTurn.values()]);
+  };
+
+  const runOnce = async ({ agent = null, lastTurn = null } = {}) => {
+    const started = performance.now();
+    try {
+      const sessionId = agent?.session?.id;
+      if (sessionId === undefined || sessionId === null) return { added: 0, skipped: 'no-session-id' };
+      // labelStamp：本 session 的 concepts.md 内容 + 阈值 + LABELER_VERSION。
+      // 拿不到 concepts.md 就不写 stamp（宁缺勿假，后续迁移会补）。
+      const conceptsText = conceptsFile && fs.existsSync(conceptsFile)
+        ? fs.readFileSync(conceptsFile, 'utf8')
+        : '';
+      const labelStamp = conceptsText ? computeLabelStamp({ conceptsText }) : null;
+      const records = loadIndexJsonl(file);
+      const maxTurn = records.reduce((max, record) => Number.isInteger(record.turn) ? Math.max(max, record.turn) : max, -1);
+      const maxSeq = records.reduce((max, record) => Number.isInteger(record.seqEnd) ? Math.max(max, record.seqEnd) : max, -1);
+      const state = readState();
+      const afterSeq = Number.isInteger(state.lastSeq) ? Math.max(maxSeq, state.lastSeq) : maxSeq;
+
+      let readMs = 0;
+      const readStarted = performance.now();
+      let events;
+      let mode = 'full';
+      if (typeof sessionQuery.readSessionTail === 'function') {
+        const snapshot = await sessionQuery.readSessionTail(sessionId, { afterSeq, limit: 512 });
+        events = snapshot?.events ?? [];
+        mode = 'tail';
+      } else {
+        const snapshot = await sessionQuery.readSession(sessionId, { afterSeq, limit: 512 });
+        events = snapshot?.events ?? [];
+        mode = events.length > 0 && events.every((event) => Number(event?.seq) > afterSeq) ? 'tail' : 'full';
+      }
+      readMs = Math.round(performance.now() - readStarted);
+
+      const missing = turnsFromEvents(events, maxTurn, afterSeq)
+        .filter((entry) => !Number.isInteger(lastTurn) || entry.turn < lastTurn);
+      const turns = missing.slice(0, maxPerRun);
+      const remaining = Math.max(0, missing.length - turns.length);
+      if (turns.length === 0) return { added: 0, maxTurn, remaining: 0, mode, readMs, totalMs: Math.round(performance.now() - started) };
+
+      const resolvedBaselineFile = baselineFile ?? path.join(path.dirname(file), 'bc-topic-baseline.json');
+      const baseline = loadBaseline(resolvedBaselineFile);
+      const topicMeans = baselineMeans(baseline, 'topics');
+      const topicFallback = baselineGlobalMean(topicMeans);
+      const workflowMeans = baselineMeans(baseline, 'workflows');
+      const workflowFallback = baselineGlobalMean(workflowMeans);
+
+      if (activeLabeler === null) activeLabeler = createBLabeler({
+        embed: embedTexts,
+        ...(labels ? { labels, concepts: Object.keys(labels) } : {}),
+        ...(kinds ? { kinds } : {}),
+      });
+      const specialKeywords = keywordsFile && !fs.existsSync(keywordsFile)
+        ? []
+        : loadSpecialKeywords(keywordsFile ?? undefined);
+      const cmapTerms = cmapFile === null
+        ? []
+        : loadCMapEntries(cmapFile)
+          .map((entry) => entry.term)
+          .filter((term) => typeof term === 'string' && term.length > 0);
+      if (cmapFile === null && !warnedMissingCmap) {
+        warnedMissingCmap = true;
+        const error = new Error('cmapFile not provided; C terms skipped');
+        error.code = 'cmap-file-missing';
+        onError?.(error);
+      }
+      const df = buildDf([
+        ...records.map((record) => (record.keywords ?? []).join(' ')),
+        ...turns.map((entry) => entry.texts.join('\n')),
+      ]);
+      const added = [];
+      const labelStarted = performance.now();
+      for (const entry of turns) {
+        const text = entry.texts.join('\n');
+        const labelOptions = {
+          topK: 3,
+          minScore: 0.25,
+          topicMinScore: 0.33,
+          topicCenterMin: 0.02,
+          topicLead: 0.02,
+          topicTopK: 1,
+          workflowTopK: 2,
+          workflowCenterMin: 0.02,
+          workflowLead: 0.02,
+          topicBaseline: topicMeans,
+          topicBaselineFallback: topicFallback,
+          workflowBaseline: workflowMeans,
+          workflowBaselineFallback: workflowFallback,
+          chunkChars: 600,
+          maxChunks: 12,
+        };
+        const label = typeof activeLabeler.labelChunked === 'function'
+          ? await activeLabeler.labelChunked(text, labelOptions)
+          : await activeLabeler.label(text, labelOptions);
+        updateBaseline(baseline, label.topicScores, 'topics');
+        updateBaseline(baseline, label.workflowScores, 'workflows');
+        const isV2 = label.version === 2;
+        const generic = label.candidates.map((candidate) => candidate.concept);
+        const conceptScores = Object.fromEntries(
+          (label.scores ? Object.entries(label.scores) : label.candidates.map((candidate) => [candidate.concept, candidate.score])),
+        );
+        const genericTopic = isV2 ? (label.topic ?? []).map((candidate) => candidate.concept) : undefined;
+        const genericWorkflow = isV2 ? (label.workflow ?? []).map((candidate) => candidate.concept) : undefined;
+        const keywords = [...new Set([
+          ...extractKeywords(text, { limit: 12 }),
+          ...matchSpecialKeywords(text, specialKeywords),
+        ])];
+        const terms = [...new Set(cmapTerms.filter((term) => text.includes(term) || keywords.includes(term)))];
+        added.push(makeRecord({
+          turn: entry.turn,
+          seqStart: entry.seqStart,
+          seqEnd: entry.seqEnd,
+          text,
+          generic,
+          ...(isV2 ? {
+            genericTopic,
+            genericWorkflow,
+            topicScore: label.topicScore,
+            topicConfidence: label.topicConfidence,
+            topicMinScore: label.topicMinScore,
+          } : {}),
+          labelVersion: isV2 ? 2 : 1,
+          ...(labelStamp ? { labelStamp } : {}),
+          terms,
+          keywords,
+          conceptScores,
+          confidence: label.top?.score ?? 0,
+          status: 'weak',
+          ...(Array.isArray(label.vector) ? { vec: Buffer.from(Float32Array.from(label.vector).buffer).toString('base64') } : {}),
+          chatter: chatterScore(text, df),
+          sessionId,
+        }));
+      }
+      const labelMs = Math.round(performance.now() - labelStarted);
+      // 先把上一轮被 gate 挡下的行并回来（按 turn 去重），再决定这次能不能写
+      const carried = takePending(sessionId);
+      if (carried.length > 0) {
+        const byTurn = new Map(carried.map((row) => [row.turn, row]));
+        for (const row of added) byTurn.set(row.turn, row);
+        added.splice(0, added.length, ...[...byTurn.values()].sort((a, b) => Number(a.turn) - Number(b.turn)));
+      }
+      // 互斥 B：正在迁移期间不写盘，且**不推进 state / 不写 baseline**
+      // 被挡的行进 pendingBySession，下一轮先合并再写——否则这些轮次会永久丢失
+      if (gate && typeof gate.isBlocked === 'function' && gate.isBlocked(sessionId)) {
+        pushPending(sessionId, added);
+        return {
+          added: 0,
+          skipped: 'relabel',
+          blocked: true,
+          pending: (pendingBySession.get(sessionId) ?? []).length,
+          maxTurn,
+        };
+      }
+      const writeStarted = performance.now();
+      saveIndexJsonl(file, [...records, ...added]);
+      saveBaseline(resolvedBaselineFile, baseline);
+      const writeMs = Math.round(performance.now() - writeStarted);
+      const lastSeq = added.at(-1)?.seqEnd ?? afterSeq;
+      const lastTurnWritten = added.at(-1)?.turn ?? maxTurn;
+      writeState({ at: new Date().toISOString(), lastSeq, lastTurn: lastTurnWritten, maxTurn: lastTurnWritten });
+      const cost = {
+        at: new Date().toISOString(),
+        added: added.length,
+        ms: Math.round(performance.now() - started),
+        readMs,
+        labelMs,
+        writeMs,
+        totalMs: Math.round(performance.now() - started),
+        maxTurn: lastTurnWritten,
+        maxSeq: lastSeq,
+        remaining,
+        mode,
+      };
+      try { onCost?.(cost); } catch { /* ignore */ }
+      return { ...cost, records: added };
+    } catch (error) {
+      try {
+        onError?.(error);
+      } catch { /* ignore */ }
+      return { added: 0, error: String(error?.message ?? error) };
+    }
+  };
+
+  const updateIndex = async (payload = {}) => {
+    if (!sessionQuery || typeof sessionQuery.readSession !== 'function') return { added: 0, skipped: 'no-session' };
+    if (runningPromise) return { added: 0, skipped: 'busy' };
+    running = true;
+    runningPromise = runOnce(payload).finally(() => {
+      running = false;
+      runningPromise = null;
+    });
+    return runningPromise;
+  };
+
+  /** 等当前这一次写盘结束（迁移开始前必须 await）。 */
+  updateIndex.whenIdle = () => runningPromise ?? Promise.resolve();
+  /** 是否正有一次写盘在跑。 */
+  updateIndex.isRunning = () => runningPromise !== null;
+  /** 被 gate 挡下的行数（观测用）。 */
+  updateIndex.pendingCount = (sessionId) => (pendingBySession.get(sessionId) ?? []).length;
+
+  return updateIndex;
+}
+
+export function defaultCostLogPath(home = process.env.USERPROFILE ?? process.env.HOME ?? '') {
+  return path.join(home, '.dsh', 'continuity', 'bc-index-cost.jsonl');
+}
+
+export function appendCostLog(file, cost) {
+  try {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, JSON.stringify(cost) + '\n', 'utf8');
+  } catch { /* cost log must not break indexing */ }
+}

package/src/memory/bc-index.mjs

@@ -0,0 +1,48 @@
+/**
+ * Compact pointer index: one JSONL line per turn, no raw text.
+ * Raw text stays in the session log; the pointer is turn + seq range.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+
+export function toPointer(record) {
+  return {
+    turn: record.turn,
+    seqStart: record.seqStart,
+    seqEnd: record.seqEnd,
+    generic: record.generic ?? [],
+    ...(Array.isArray(record.genericTopic) ? { genericTopic: record.genericTopic } : {}),
+    ...(Array.isArray(record.genericWorkflow) ? { genericWorkflow: record.genericWorkflow } : {}),
+    ...(Number.isFinite(record.topicScore) ? { topicScore: record.topicScore } : {}),
+    ...(typeof record.topicConfidence === 'string' && record.topicConfidence ? { topicConfidence: record.topicConfidence } : {}),
+    ...(Number.isFinite(record.topicMinScore) ? { topicMinScore: record.topicMinScore } : {}),
+    ...(typeof record.labelStamp === 'string' && record.labelStamp ? { labelStamp: record.labelStamp } : {}),
+    labelVersion: Number.isInteger(record.labelVersion) ? record.labelVersion : 1,
+    terms: record.terms ?? [],
+    keywords: record.keywords ?? [],
+    backfilled: record.backfilled ?? [],
+    conceptScores: record.conceptScores ?? {},
+    confidence: record.confidence ?? 0,
+    status: record.status ?? 'weak',
+    ...(typeof record.vec === 'string' && record.vec ? { vec: record.vec } : {}),
+    ...(Number.isFinite(record.chatter) ? { chatter: Number(record.chatter) } : {}),
+    ...(typeof record.sessionId === 'string' && record.sessionId ? { sessionId: record.sessionId } : {}),
+  };
+}
+
+export function saveIndexJsonl(file, records = []) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  const temp = `${file}.tmp-${process.pid}`;
+  fs.writeFileSync(temp, records.map((record) => JSON.stringify(toPointer(record))).join('\n') + (records.length > 0 ? '\n' : ''), 'utf8');
+  fs.renameSync(temp, file);
+  return file;
+}
+
+export function loadIndexJsonl(file) {
+  if (!fs.existsSync(file)) return [];
+  return fs.readFileSync(file, 'utf8').split(/\r?\n/).filter(Boolean)
+    .map((line) => {
+      const record = JSON.parse(line.replace(/^\uFEFF/, ''));
+      return { labelVersion: 1, ...record };
+    });
+}

package/src/memory/bc-label.mjs

@@ -0,0 +1,220 @@
+/**
+ * B-layer labeling: frozen embedding + generic concept descriptions.
+ *
+ * No LLM, no network, no writes. One BGE load can label many texts.
+ */
+import { GENERIC_CONCEPTS } from './bc-recall.mjs';
+
+/**
+ * labeler 判定语义的版本号（手工维护）。
+ *
+ * 只有"会改变打标结果"的改动才 bump：
+ *   · 分块规则 / 阈值默认值 / center 与 lead 判据
+ *   · 概念描述的相似度计算方式
+ *   · 文本拼接规则（user 在前、去 reasoning 等）
+ * 纯文档、纯日志、纯 UI 改动**不要** bump——否则 labelStamp 全员失效，
+ * 触发一次 30 分钟的全量重扫，与"增量/不扫"的目标冲突（创 2026-11-04 定）。
+ *
+ * marker.labelerVersion 只在回归测试时显式覆盖它，默认用本常量。
+ */
+export const LABELER_VERSION = 1;
+
+export const GENERIC_LABELS = Object.freeze({
+  游戏: '游戏、桌游、跑团、角色扮演、掷骰、回合制',
+  故事: '故事、剧情、叙事、角色、对白、场景',
+  对话: '对话、聊天、讨论、交流',
+  技术: '技术、代码、程序、系统、开发、调试',
+  设备: '设备、硬件、机器、工具、图像',
+  规则: '规则、规定、制度、约束、流程',
+  记忆: '记忆、回忆、历史、上下文、连续性',
+  剧情: '剧情、情节、故事发展、角色行动',
+  病毒: '病毒、传染病、疫情、病原体、公共卫生',
+  公共卫生: '公共卫生、防疫、传播、疾病控制',
+  科学: '科学、研究、实验、论文、证据',
+});
+
+function normalizeVector(vector) {
+  const norm = Math.sqrt(vector.reduce((sum, value) => sum + value * value, 0)) || 1;
+  return vector.map((value) => value / norm);
+}
+
+function cosine(a, b) {
+  let dot = 0;
+  for (let index = 0; index < Math.min(a.length, b.length); index += 1) dot += a[index] * b[index];
+  return dot;
+}
+
+function chunkText(text, { chunkChars = 600, maxChunks = 12 } = {}) {
+  const value = String(text ?? '');
+  if (value.length <= chunkChars) return [value];
+  const chunks = [];
+  for (let start = 0; start < value.length && chunks.length < maxChunks; start += chunkChars) {
+    chunks.push(value.slice(start, start + chunkChars));
+  }
+  return chunks;
+}
+
+export function createBLabeler({ embed = null, concepts = GENERIC_CONCEPTS, labels = GENERIC_LABELS, kinds = null } = {}) {
+  if (typeof embed !== 'function') throw new Error('B labeler needs an embed function');
+  let ready = null;
+  const names = concepts.filter((concept) => labels[concept]);
+  const split = kinds !== null && typeof kinds === 'object' && Object.keys(kinds).length > 0;
+  const kindOf = (concept) => (kinds?.[concept] === 'workflow' ? 'workflow' : 'topic');
+  // topicConfidence is a display label; 0.4/0.5 are not write thresholds.
+  const confidenceOf = (score) => (score >= 0.5 ? 'normal' : score >= 0.4 ? 'low' : 'weak');
+  async function prepare() {
+    if (ready !== null) return ready;
+    const vectors = names.length > 0 ? await embed(names.map((concept) => labels[concept])) : [];
+    ready = { labels: names, vectors: vectors.map(normalizeVector) };
+    return ready;
+  }
+  function decide(scored, {
+    topK = 3,
+    minScore = 0.25,
+    topicMinScore = 0.33,
+    topicCenterMin = 0.02,
+    topicLead = 0.02,
+    topicTopK = 1,
+    workflowTopK = 2,
+    workflowCenterMin = 0.02,
+    workflowLead = 0.02,
+    topicBaseline = null,
+    topicBaselineFallback = null,
+    workflowBaseline = null,
+    workflowBaselineFallback = null,
+    vector = [],
+    chunks = 1,
+  } = {}) {
+    if (split) {
+      const topics = scored
+        .filter((item) => kindOf(item.concept) === 'topic')
+        .map((item) => {
+          const center = Number.isFinite(topicBaseline?.[item.concept])
+            ? topicBaseline[item.concept]
+            : (Number.isFinite(topicBaselineFallback) ? topicBaselineFallback : 0);
+          return {
+            concept: item.concept,
+            score: item.score,
+            rawScore: item.score,
+            centered: item.score - center,
+          };
+        })
+        .sort((a, b) => b.centered - a.centered);
+      const topTopic = topics[0];
+      const secondTopic = topics[1];
+      const topicPasses = topTopic !== undefined
+        && topTopic.rawScore >= topicMinScore
+        && topTopic.centered >= topicCenterMin
+        && (secondTopic === undefined || topTopic.centered - secondTopic.centered >= topicLead);
+      const topicCandidates = topicPasses
+        ? topics.slice(0, Math.max(1, topicTopK))
+        : [];
+      const workflows = scored
+        .filter((item) => kindOf(item.concept) === 'workflow')
+        .map((item) => {
+          const center = Number.isFinite(workflowBaseline?.[item.concept])
+            ? workflowBaseline[item.concept]
+            : (Number.isFinite(workflowBaselineFallback) ? workflowBaselineFallback : 0);
+          return {
+            concept: item.concept,
+            score: item.score,
+            rawScore: item.score,
+            centered: item.score - center,
+          };
+        })
+        .sort((a, b) => b.centered - a.centered);
+      const topWorkflow = workflows[0];
+      const secondWorkflow = workflows[1];
+      const workflowPasses = topWorkflow !== undefined
+        && topWorkflow.rawScore >= minScore
+        && topWorkflow.centered >= workflowCenterMin
+        && (secondWorkflow === undefined || topWorkflow.centered - secondWorkflow.centered >= workflowLead);
+      const workflow = workflowPasses
+        ? workflows
+          .slice(0, Math.max(0, workflowTopK))
+          .filter((item) => item.rawScore >= minScore && item.centered >= workflowCenterMin)
+        : [];
+      const candidates = [...topicCandidates, ...workflow]
+        .sort((a, b) => b.rawScore - a.rawScore)
+        .slice(0, topicCandidates.length + workflowTopK);
+      const scores = Object.fromEntries([...topicCandidates, ...workflow].map((item) => [item.concept, item.rawScore]));
+      return {
+        candidates,
+        topic: topicCandidates,
+        workflow,
+        scores,
+        topicScores: Object.fromEntries(topics.map((item) => [item.concept, item.rawScore])),
+        topicCenteredScores: Object.fromEntries(topics.map((item) => [item.concept, item.centered])),
+        workflowScores: Object.fromEntries(workflows.map((item) => [item.concept, item.rawScore])),
+        workflowCenteredScores: Object.fromEntries(workflows.map((item) => [item.concept, item.centered])),
+        topicScore: topicCandidates.length > 0 ? topTopic.rawScore : null,
+        topicCenteredScore: topicCandidates.length > 0 ? topTopic.centered : null,
+        topicConfidence: topicCandidates.length > 0 ? confidenceOf(topTopic.rawScore) : null,
+        topicMinScore,
+        topicCenterMin,
+        topicLead,
+        workflowCenterMin,
+        workflowLead,
+        topicBaseline,
+        topicBaselineFallback,
+        workflowBaseline,
+        workflowBaselineFallback,
+        chunks,
+        unknown: candidates.length === 0,
+        top: topicCandidates[0] ?? workflow[0] ?? null,
+        vector,
+        version: 2,
+      };
+    }
+    const candidates = scored.filter((item) => item.score >= minScore).slice(0, topK);
+    return {
+      candidates,
+      unknown: candidates.length === 0 || candidates[0].score < minScore,
+      top: candidates[0] ?? null,
+      vector,
+    };
+  }
+  return {
+    async label(text, options = {}) {
+      const prepared = await prepare();
+      const [rawVector] = await embed([String(text ?? '')]);
+      const vector = normalizeVector(rawVector);
+      if (prepared.labels.length === 0) {
+        return { candidates: [], unknown: true, top: null, vector, ...(split ? { version: 2, topic: [], workflow: [], scores: {} } : {}) };
+      }
+      const scored = prepared.labels.map((concept, index) => ({
+        concept,
+        score: cosine(vector, prepared.vectors[index]),
+      })).sort((a, b) => b.score - a.score);
+      return decide(scored, { ...options, vector, chunks: 1 });
+    },
+    async labelChunked(text, options = {}) {
+      const prepared = await prepare();
+      const chunks = chunkText(text, options);
+      if (prepared.labels.length === 0) {
+        return { candidates: [], unknown: true, top: null, vector: [], ...(split ? { version: 2, topic: [], workflow: [], scores: {} } : {}) };
+      }
+      const best = new Map();
+      const vectors = [];
+      for (const chunk of chunks) {
+        const [rawVector] = await embed([chunk]);
+        const vector = normalizeVector(rawVector);
+        vectors.push(vector);
+        for (let index = 0; index < prepared.labels.length; index += 1) {
+          const concept = prepared.labels[index];
+          const score = cosine(vector, prepared.vectors[index]);
+          if (!best.has(concept) || score > best.get(concept)) best.set(concept, score);
+        }
+      }
+      const summed = new Array(vectors[0]?.length ?? 0).fill(0);
+      for (const vector of vectors) {
+        for (let index = 0; index < summed.length; index += 1) summed[index] += vector[index] ?? 0;
+      }
+      const vector = normalizeVector(summed);
+      const scored = [...best.entries()]
+        .map(([concept, score]) => ({ concept, score }))
+        .sort((a, b) => b.score - a.score);
+      return decide(scored, { ...options, vector, chunks: chunks.length });
+    },
+  };
+}