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

package/bin/facet-online-experiments.mjs

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { embedTexts } from '../src/facets/embedding.mjs';
+import { OnlineFacetKnn } from '../src/facets/online-knn.mjs';
+import { seedRows } from '../src/facets/seed-examples.mjs';
+import { detectRandom } from '../src/facets/random.mjs';
+import { SLOTS, normalizeFacets } 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 input = argOf('--input');
+if (!input) {
+  console.error('usage: node bin/facet-online-experiments.mjs --input early50-labeled.jsonl');
+  process.exit(2);
+}
+const rows = fs.readFileSync(input, 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+const vectors = await embedTexts(rows.map((row) => row.text));
+const seedData = seedRows();
+const seedVectors = await embedTexts(seedData.map((row) => row.text));
+
+function makeLearner(useSeeds) {
+  const learner = new OnlineFacetKnn({ k: 5, minSimilarity: 0.15, minVote: 0.5 });
+  if (useSeeds) seedData.forEach((row, index) => learner.add(seedVectors[index], row.facets));
+  return learner;
+}
+
+function evaluate({ useSeeds = false, warm = 0, temporal = false } = {}) {
+  const learner = makeLearner(useSeeds);
+  const report = Object.fromEntries(SLOTS.map((slot) => [slot, { total: 0, covered: 0, correct: 0 }]));
+  const timeline = [];
+  let previous = {};
+  for (let index = 0; index < rows.length; index += 1) {
+    const row = rows[index];
+    const truth = normalizeFacets(row.facets ?? {});
+    if (index >= warm) {
+      const predicted = learner.predict(vectors[index]);
+      if (temporal) {
+        for (const slot of SLOTS) {
+          if (predicted.facets[slot] === undefined && previous[slot] !== undefined) {
+            predicted.facets[slot] = previous[slot];
+          }
+        }
+      }
+      predicted.facets.random = detectRandom(row.text).value;
+      previous = { ...predicted.facets };
+      timeline.push({ turn: row.turn, facets: predicted.facets, unknown: predicted.unknown });
+      for (const slot of SLOTS) {
+        if (truth[slot] === undefined) continue;
+        report[slot].total += 1;
+        if (predicted.facets[slot] === undefined) continue;
+        report[slot].covered += 1;
+        if (predicted.facets[slot] === truth[slot]) report[slot].correct += 1;
+      }
+    }
+    learner.add(vectors[index], truth);
+  }
+  for (const slot of SLOTS) {
+    const row = report[slot];
+    row.coverage = row.total === 0 ? 0 : row.covered / row.total;
+    row.accuracy = row.covered === 0 ? 0 : row.correct / row.covered;
+  }
+  return { report, timeline };
+}
+
+const result = {
+  baseline: evaluate(),
+  schemaSeeds: evaluate({ useSeeds: true }),
+  warm10: evaluate({ warm: 10 }),
+  warm10Seeds: evaluate({ useSeeds: true, warm: 10 }),
+  warm10Temporal: evaluate({ warm: 10, temporal: true }),
+};
+fs.writeFileSync(`${input}.online-experiments.json`, `${JSON.stringify(result, null, 2)}\n`, 'utf8');
+const out = Object.fromEntries(Object.entries(result).map(([name, value]) => [name, Object.fromEntries(Object.entries(value.report).map(([slot, row]) => [slot, `${(row.accuracy * 100).toFixed(1)}% @ ${(row.coverage * 100).toFixed(1)}%`]))]));
+console.log(JSON.stringify(out, null, 2));
+

package/bin/facet-online-race.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env node
+/**
+ * Race true incremental learners from turn 1.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { performance } from 'node:perf_hooks';
+import { OnlineFacetKnn } from '../src/facets/online-knn.mjs';
+import { OnlineCentroid, OnlineCentroidVariance, OnlineNaiveBayes } from '../src/facets/online-models.mjs';
+import { detectRandom } from '../src/facets/random.mjs';
+import { SLOTS } 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') ?? 'C:/Users/35794/Documents/DeepSeek\'s Sandbox/coopanion-continuity/backups/continuity-tags-20261031/online400';
+const rows = fs.readFileSync(path.join(dir, 'continuity-1500.jsonl'), 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+const embeddings = JSON.parse(fs.readFileSync(path.join(dir, 'embeddings-1500.json'), 'utf8'));
+const vectorByTurn = new Map(embeddings.map((row) => [row.turn, row.vector]));
+const checkpoints = [50, 100, 200, 400, 800, 1200, 1480];
+
+function evaluate(name, learner, predictFn, updateFn) {
+  const report = Object.fromEntries(SLOTS.map((slot) => [slot, { total: 0, covered: 0, correct: 0 }]));
+  const checkpointsOut = [];
+  let unknown = 0;
+  let checkpointIndex = 0;
+  const t0 = performance.now();
+  for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
+    const row = rows[rowIndex];
+    const vector = vectorByTurn.get(row.turn);
+    const predicted = predictFn(learner, row.text, vector);
+    predicted.facets.random = detectRandom(row.text).value;
+    if (predicted.unknown) unknown += 1;
+    for (const slot of SLOTS) {
+      if (row.facets[slot] === undefined) continue;
+      report[slot].total += 1;
+      if (predicted.facets[slot] === undefined) continue;
+      report[slot].covered += 1;
+      if (predicted.facets[slot] === row.facets[slot]) report[slot].correct += 1;
+    }
+    updateFn(learner, vector, row.text, row.facets);
+    while (checkpointIndex < checkpoints.length && row.turn >= checkpoints[checkpointIndex]) {
+      const checkpoint = checkpoints[checkpointIndex];
+      checkpointIndex += 1;
+      const rep = {};
+      for (const slot of SLOTS) {
+        const x = report[slot];
+        rep[slot] = {
+          total: x.total,
+          covered: x.covered,
+          correct: x.correct,
+          coverage: x.total === 0 ? 0 : x.covered / x.total,
+          accuracy: x.covered === 0 ? 0 : x.correct / x.covered,
+        };
+      }
+      checkpointsOut.push({ turn: row.turn, checkpoint, indexed: rowIndex + 1, unknown, report: rep });
+    }
+  }
+  const mem = process.memoryUsage();
+  const elapsed = performance.now() - t0;
+  return {
+    name,
+    rows: rows.length,
+    timeMs: Math.round(elapsed),
+    msPerTurn: +(elapsed / rows.length).toFixed(2),
+    memory: { heapMB: +(mem.heapUsed / 1048576).toFixed(1), rssMB: +(mem.rss / 1048576).toFixed(1) },
+    checkpoints: checkpointsOut,
+  };
+}
+
+const results = [];
+results.push(evaluate('centroid', new OnlineCentroid(),
+  (m, text, vector) => m.predict(vector),
+  (m, vector, text, facets) => m.update(vector, facets)));
+results.push(evaluate('centroidVariance', new OnlineCentroidVariance(),
+  (m, text, vector) => m.predict(vector),
+  (m, vector, text, facets) => m.update(vector, facets)));
+results.push(evaluate('naiveBayes', new OnlineNaiveBayes(),
+  (m, text) => m.predict(text),
+  (m, vector, text, facets) => m.update(text, facets)));
+results.push(evaluate('knn', new OnlineFacetKnn({ k: 5, minSimilarity: 0.15, minVote: 0.5 }),
+  (m, text, vector) => m.predict(vector),
+  (m, vector, text, facets) => m.add(vector, facets)));
+
+fs.writeFileSync(path.join(dir, 'ONLINE-RACE-1462.json'), JSON.stringify(results, null, 2));
+const summary = results.map((r) => ({
+  name: r.name,
+  msPerTurn: r.msPerTurn,
+  memory: r.memory,
+  checkpoints: r.checkpoints.map((c) => ({
+    checkpoint: c.checkpoint,
+    activity: c.report.activity.accuracy,
+    topic: c.report.topic.accuracy,
+    coverage: [c.report.activity.coverage, c.report.topic.coverage],
+  })),
+}));
+console.log(JSON.stringify(summary, null, 2));

package/bin/facet-online-validate.mjs

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+/**
+ * Prequential validation: predict turn t from turns < t, then learn t.
+ */
+import fs from 'node:fs';
+import { embedTexts } from '../src/facets/embedding.mjs';
+import { OnlineFacetKnn } from '../src/facets/online-knn.mjs';
+import { detectRandom } from '../src/facets/random.mjs';
+import { SLOTS, normalizeFacets } 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 input = argOf('--input');
+const model = argOf('--model') ?? 'Xenova/bge-small-zh-v1.5';
+if (!input) {
+  console.error('usage: node bin/facet-online-validate.mjs --input early50-labeled.jsonl');
+  process.exit(2);
+}
+const rows = fs.readFileSync(input, 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+const vectors = await embedTexts(rows.map((row) => row.text), model);
+const learner = new OnlineFacetKnn({ k: 5, minSimilarity: 0.15, minVote: 0.5 });
+const report = {};
+for (const slot of SLOTS) report[slot] = { total: 0, covered: 0, correct: 0 };
+let unknownTurns = 0;
+const timeline = [];
+for (let index = 0; index < rows.length; index += 1) {
+  const row = rows[index];
+  const truth = normalizeFacets(row.facets ?? {});
+  const predicted = learner.predict(vectors[index]);
+  if (predicted.unknown) unknownTurns += 1;
+  predicted.facets.random = detectRandom(row.text).value;
+  const entry = { turn: row.turn, unknown: predicted.unknown, facets: predicted.facets };
+  timeline.push(entry);
+  for (const slot of SLOTS) {
+    if (truth[slot] === undefined) continue;
+    report[slot].total += 1;
+    if (predicted.facets[slot] === undefined) continue;
+    report[slot].covered += 1;
+    if (predicted.facets[slot] === truth[slot]) report[slot].correct += 1;
+  }
+  learner.add(vectors[index], truth);
+}
+for (const slot of SLOTS) {
+  const row = report[slot];
+  row.coverage = row.total === 0 ? 0 : row.covered / row.total;
+  row.accuracy = row.covered === 0 ? 0 : row.correct / row.covered;
+}
+console.log(JSON.stringify({ rows: rows.length, unknownTurns, report, timeline }, null, 2));

package/bin/facet-panel.mjs

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { buildFacetIndex } from '../src/facets/index.mjs';
+import { buildFacetPanel } from '../src/facets/panel.mjs';
+
+const args = process.argv.slice(2);
+const argOf = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+};
+const input = argOf('--input');
+const out = argOf('--out');
+const alias = argOf('--alias') ?? '跑团';
+if (!input || !out) {
+  console.error('usage: node bin/facet-panel.mjs --input rows.jsonl --out facet-panel.json --alias 跑团');
+  process.exit(2);
+}
+const rows = fs.readFileSync(input, 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+const index = buildFacetIndex(rows);
+const panel = buildFacetPanel(index.entries, { idf: index.idf, currentAlias: alias });
+fs.writeFileSync(out, `${JSON.stringify(panel, null, 2)}\n`, 'utf8');
+console.log(JSON.stringify({ out, total: panel.totalTurns, facetSum: panel.facetSum, currentTopic: panel.currentTopic?.alias }, null, 2));

package/bin/facet-passage.mjs

@@ -0,0 +1,41 @@
+import fs from 'node:fs';
+import { deserializePrototypes, predictEmbedding } from '../src/facets/embedding.mjs';
+import { deserializeClassifier, predictFacets } from '../src/facets/classifier.mjs';
+
+const full = `宁把手里那只凉箍交给柯林，箍口朝上塞进他布袋：
+
+「你拿着，别落地，也别让它见水。」
+
+然后他自己转到闸门侧面去找那个起闸的轮子——不是去接，是去卡：
+
+「闸一开就接人是吧？」他蹲下去看链条和卡齿，「那今晚就先让闸开不了。」
+
+（@Coo：闸的起落机构是什么样的？能卡在哪儿？）`;
+
+const variants = {
+  full,
+  no_ooc: full.replace(/（@Coo：[\s\S]*?）\s*$/, '').trim(),
+  action_only: `宁把手里那只凉箍交给柯林，箍口朝上塞进他布袋：「你拿着，别落地，也别让它见水。」然后他自己转到闸门侧面去找那个起闸的轮子——不是去接，是去卡：「闸一开就接人是吧？」他蹲下去看链条和卡齿，「那今晚就先让闸开不了。」`,
+  first_para: `宁把手里那只凉箍交给柯林，箍口朝上塞进他布袋：「你拿着，别落地，也别让它见水。」`,
+  second_para: `然后他自己转到闸门侧面去找那个起闸的轮子——不是去接，是去卡：「闸一开就接人是吧？」他蹲下去看链条和卡齿，「那今晚就先让闸开不了。」`,
+  ooc_only: `（@Coo：闸的起落机构是什么样的？能卡在哪儿？）`,
+};
+
+const prototypes = deserializePrototypes(JSON.parse(fs.readFileSync('C:/Users/35794/Documents/DeepSeek\'s Sandbox/coopanion-continuity/backups/continuity-tags-20261031/last100/facet-prototypes.json', 'utf8')));
+const nb = deserializeClassifier(JSON.parse(fs.readFileSync('C:/Users/35794/Documents/DeepSeek\'s Sandbox/coopanion-continuity/backups/continuity-tags-20261031/last100/facet-model.json', 'utf8')));
+
+const out = {};
+for (const [name, text] of Object.entries(variants)) {
+  const started = Date.now();
+  const embedding = await predictEmbedding(prototypes, text);
+  const embMs = Date.now() - started;
+  const n = predictFacets(nb, text);
+  out[name] = {
+    chars: [...text].length,
+    embedding: embedding.facets,
+    confidence: embedding.confidence,
+    ms: embMs,
+    nb: n.facets,
+  };
+}
+console.log(JSON.stringify(out, null, 2));

package/bin/facet-random-validate.mjs

@@ -0,0 +1,48 @@
+#!/usr/bin/env node
+/**
+ * Random-facet sanity check.
+ *
+ * Positive labels are explicit mechanics words (rule-derived, not human gold).
+ * The detector is intentionally allowed to use the same signal; this verifies
+ * that the old all-"无" collapse is gone, not that the rule generalizes.
+ */
+import fs from 'node:fs';
+import { detectRandom } from '../src/facets/random.mjs';
+
+const args = process.argv.slice(2);
+const argOf = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+};
+const input = argOf('--input');
+if (!input) {
+  console.error('usage: node bin/facet-random-validate.mjs --input rows.jsonl');
+  process.exit(2);
+}
+const rows = fs.readFileSync(input, 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+const STRONG = ['掷骰', '骰子', '骰', 'd20', '检定', '抽卡'];
+const isPositiveLabel = (text) => STRONG.some((hint) => String(text ?? '').toLowerCase().includes(hint));
+let positive = 0;
+let hit = 0;
+let falsePositive = 0;
+let negative = 0;
+const examples = [];
+for (const row of rows) {
+  const label = isPositiveLabel(row.text) ? '有' : '无';
+  const predicted = detectRandom(row.text);
+  if (label === '有') positive += 1;
+  else negative += 1;
+  if (label === '有' && predicted.value === '有') hit += 1;
+  if (label === '无' && predicted.value === '有') falsePositive += 1;
+  if (label === '有') examples.push({ turn: row.turn, hits: predicted.hits });
+}
+console.log(JSON.stringify({
+  total: rows.length,
+  positive,
+  negative,
+  recall: positive === 0 ? 0 : hit / positive,
+  falsePositive,
+  precision: hit + falsePositive === 0 ? 0 : hit / (hit + falsePositive),
+  positiveRate: rows.length === 0 ? 0 : positive / rows.length,
+  examples: examples.slice(0, 10),
+}, null, 2));

package/bin/facet-roleplay.mjs

@@ -0,0 +1,33 @@
+import fs from 'node:fs';
+import { extractFacets } from '../src/facets/extract.mjs';
+import { deserializeClassifier, predictFacets } from '../src/facets/classifier.mjs';
+import { deserializePrototypes, predictEmbedding } from '../src/facets/embedding.mjs';
+
+const rows = fs.readFileSync('C:/Users/35794/Documents/DeepSeek\'s Sandbox/coopanion-continuity/backups/continuity-tags-20261031/online400/continuity-1500.jsonl', 'utf8')
+  .split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+const nb = deserializeClassifier(JSON.parse(fs.readFileSync('C:/Users/35794/Documents/DeepSeek\'s Sandbox/coopanion-continuity/backups/continuity-tags-20261031/last100/facet-model.json', 'utf8')));
+const prototypes = deserializePrototypes(JSON.parse(fs.readFileSync('C:/Users/35794/Documents/DeepSeek\'s Sandbox/coopanion-continuity/backups/continuity-tags-20261031/last100/facet-prototypes.json', 'utf8')));
+const turns = [2, 3, 40, 41, 42, 43, 49, 81, 82, 84];
+const out = [];
+for (const turn of turns) {
+  const row = rows.find((item) => Number(item.turn) === turn);
+  if (!row) continue;
+  const before = Date.now();
+  const rule = extractFacets(row.text);
+  const ruleMs = Date.now() - before;
+  const started = Date.now();
+  const nbResult = predictFacets(nb, row.text);
+  const nbMs = Date.now() - started;
+  const embStarted = Date.now();
+  const emb = await predictEmbedding(prototypes, row.text);
+  out.push({
+    turn,
+    truth: row.facets,
+    rule: { facets: rule.facets, confidence: rule.confidence, ms: ruleMs },
+    nb: { facets: nbResult.facets, confidence: nbResult.confidence, ms: nbMs },
+    embedding: { facets: emb.facets, confidence: emb.confidence, ms: Date.now() - embStarted },
+    head: String(row.text).replace(/\s+/g, ' ').slice(0, 240),
+  });
+}
+fs.writeFileSync('C:/Users/35794/Documents/DeepSeek\'s Sandbox/coopanion-continuity/backups/continuity-tags-20261031/durable-memory/build-a/FACET-ROLEPLAY.json', JSON.stringify(out, null, 2));
+console.log(JSON.stringify(out, null, 2));

package/bin/facet-scan.mjs

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+/**
+ * Incremental facet scan CLI.
+ *
+ * node bin/facet-scan.mjs --input rows.jsonl --dir .facet --query 跑团
+ *
+ * rows: { turn, seqStart, seqEnd, text?, facets? }
+ * Files: facet-index.json, facet-cursor.json, facet-residual.jsonl
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { buildFacetIndex, queryFacets, indexStats } from '../src/facets/index.mjs';
+import { emptyCursor, scanRows, residualCount } from '../src/facets/scanner.mjs';
+import { loadCursor, loadIndex, saveCursor, saveIndex } from '../src/facets/store.mjs';
+import { classifierExtractor, deserializeClassifier } from '../src/facets/classifier.mjs';
+
+const args = process.argv.slice(2);
+const argOf = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+};
+const input = argOf('--input');
+const dir = argOf('--dir') ?? '.facet';
+const query = argOf('--query') ?? '跑团';
+const modelFile = argOf('--model');
+if (!input) {
+  console.error('usage: node bin/facet-scan.mjs --input rows.jsonl --dir .facet --query 跑团 [--model facet-model.json]');
+  process.exit(2);
+}
+const extract = modelFile !== undefined
+  ? classifierExtractor(deserializeClassifier(JSON.parse(fs.readFileSync(modelFile, 'utf8'))))
+  : undefined;
+const rows = fs.readFileSync(input, 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+fs.mkdirSync(dir, { recursive: true });
+const indexFile = path.join(dir, 'facet-index.json');
+const cursorFile = path.join(dir, 'facet-cursor.json');
+const residualFile = path.join(dir, 'facet-residual.jsonl');
+
+const previous = fs.existsSync(indexFile) ? loadIndex(indexFile) : { entries: [] };
+const cursor = loadCursor(cursorFile) ?? emptyCursor();
+const scanResult = scanRows(rows, cursor, extract === undefined ? {} : { extract });
+const merged = [...previous.entries, ...scanResult.entries];
+const index = buildFacetIndex(merged);
+saveIndex(indexFile, index);
+saveCursor(cursorFile, scanResult.cursor);
+fs.writeFileSync(residualFile, (scanResult.cursor.residual ?? []).map((row) => JSON.stringify(row)).join('\n') + '\n', 'utf8');
+
+const result = queryFacets(index, query, { topK: 50 });
+console.log(JSON.stringify({
+  stats: indexStats(index),
+  scanned: scanResult.entries.length,
+  residual: residualCount(scanResult.cursor),
+  query: { name: result.query, facets: result.facets },
+  matchCount: result.matches.length,
+  ranges: result.ranges,
+}, null, 2));

package/bin/facet-segment.mjs

@@ -0,0 +1,34 @@
+import fs from 'node:fs';
+import { deserializePrototypes, predictEmbedding } from '../src/facets/embedding.mjs';
+
+const prototypes = deserializePrototypes(JSON.parse(fs.readFileSync('C:/Users/35794/Documents/DeepSeek\'s Sandbox/coopanion-continuity/backups/continuity-tags-20261031/last100/facet-prototypes.json', 'utf8')));
+const text = `宁把手里那只凉箍交给柯林，箍口朝上塞进他布袋：
+
+「你拿着，别落地，也别让它见水。」
+
+然后他自己转到闸门侧面去找那个起闸的轮子——不是去接，是去卡：
+
+「闸一开就接人是吧？」他蹲下去看链条和卡齿，「那今晚就先让闸开不了。」
+
+（@Coo：闸的起落机构是什么样的？能卡在哪儿？）`;
+
+const segments = text.split(/\n{2,}/).map((part) => part.trim()).filter(Boolean).map((part) => ({
+  kind: /^[（(]\s*@/.test(part) ? 'ooc' : 'story',
+  text: part,
+}));
+const out = [];
+for (const segment of segments) {
+  if (segment.kind === 'ooc') {
+    out.push({ ...segment, facets: null, reason: 'ooc-skip' });
+    continue;
+  }
+  const result = await predictEmbedding(prototypes, segment.text);
+  const accepted = (result.confidence.activity ?? 0) >= 0.05 && (result.confidence.topic ?? 0) >= 0.03;
+  out.push({
+    ...segment,
+    facets: accepted ? result.facets : null,
+    confidence: result.confidence,
+    reason: accepted ? 'accepted' : 'low-confidence',
+  });
+}
+console.log(JSON.stringify(out, null, 2));

package/bin/facet-train.mjs

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { trainFacetClassifier, evaluate, serializeClassifier } from '../src/facets/classifier.mjs';
+
+const args = process.argv.slice(2);
+const argOf = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+};
+const input = argOf('--input');
+const out = argOf('--out') ?? 'facet-model.json';
+if (!input) {
+  console.error('usage: node bin/facet-train.mjs --input rows.jsonl --out facet-model.json');
+  process.exit(2);
+}
+const rows = fs.readFileSync(input, 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+const model = trainFacetClassifier(rows);
+fs.writeFileSync(out, `${JSON.stringify(serializeClassifier(model))}\n`, 'utf8');
+console.log(JSON.stringify({ input: rows.length, out, report: evaluate(model, rows) }, null, 2));

package/bin/facet-validate.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+/**
+ * Closed-loop validation:
+ * stratified holdout -> train local NB -> hybrid extract -> index -> alias query.
+ *
+ * Input rows: { turn, seqStart, seqEnd, text, facets }
+ * `facets` is the accepted model label used only for training/evaluation.
+ */
+import fs from 'node:fs';
+import { trainFacetClassifier } from '../src/facets/classifier.mjs';
+import { hybridExtractor } from '../src/facets/hybrid.mjs';
+import { buildFacetIndex, queryFacets, indexStats } from '../src/facets/index.mjs';
+import { SLOTS, normalizeFacets } 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 input = argOf('--input');
+const query = argOf('--query') ?? '跑团';
+if (!input) {
+  console.error('usage: node bin/facet-validate.mjs --input rows.jsonl [--query 跑团]');
+  process.exit(2);
+}
+const rows = fs.readFileSync(input, 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+
+const groups = new Map();
+for (const row of rows) {
+  const activity = normalizeFacets(row.facets ?? {}).activity ?? '其他';
+  if (!groups.has(activity)) groups.set(activity, []);
+  groups.get(activity).push(row);
+}
+const train = [];
+const test = [];
+for (const list of groups.values()) {
+  list.sort((a, b) => a.turn - b.turn);
+  list.forEach((row, index) => (index % 2 === 0 ? train : test).push(row));
+}
+
+const model = trainFacetClassifier(train);
+const extract = hybridExtractor(model);
+
+function evaluate(rowsToTest) {
+  const report = {};
+  for (const slot of SLOTS) {
+    let total = 0;
+    let correct = 0;
+    let covered = 0;
+    for (const row of rowsToTest) {
+      const truth = normalizeFacets(row.facets ?? {})[slot];
+      if (truth === undefined) continue;
+      total += 1;
+      const predicted = extract(row.text).facets[slot];
+      if (predicted === undefined) continue;
+      covered += 1;
+      if (predicted === truth) correct += 1;
+    }
+    report[slot] = {
+      total,
+      covered,
+      correct,
+      coverage: total === 0 ? 0 : covered / total,
+      accuracy: covered === 0 ? 0 : correct / covered,
+    };
+  }
+  return report;
+}
+
+const testRows = test.map((row) => ({
+  turn: row.turn,
+  seqStart: row.seqStart,
+  seqEnd: row.seqEnd,
+  text: row.text,
+}));
+const index = buildFacetIndex(testRows, { extract });
+const result = queryFacets(index, query, { topK: testRows.length, minCoverage: 0.6 });
+const truthRun = new Set(test
+  .filter((row) => normalizeFacets(row.facets ?? {}).activity === '跑团')
+  .map((row) => row.turn));
+const foundRun = new Set(result.matches
+  .filter((hit) => truthRun.has(hit.turn) || true)
+  .map((hit) => hit.turn)
+  .filter((turn) => truthRun.has(turn)));
+const truePositive = result.matches.filter((hit) => truthRun.has(hit.turn)).length;
+const precision = result.matches.length === 0 ? 0 : truePositive / result.matches.length;
+const recall = truthRun.size === 0 ? 0 : truePositive / truthRun.size;
+
+console.log(JSON.stringify({
+  split: { train: train.length, test: test.length },
+  accuracy: evaluate(test),
+  index: indexStats(index),
+  query: {
+    name: result.query,
+    facets: result.facets,
+    matches: result.matches.length,
+    truthRun: truthRun.size,
+    truePositive,
+    precision,
+    recall,
+    ranges: result.ranges,
+  },
+}, null, 2));

package/bin/facet-zeroshot.mjs

@@ -0,0 +1,14 @@
+import { embedTexts } from '../src/facets/embedding.mjs';
+
+const keywords = ['COVID-19', '实验室泄漏', '自然宿主', '冷链传播'];
+const labels = ['病毒', '疫情', '公共卫生', '技术', '设备', '剧情', '其他'];
+const vectors = await embedTexts([...keywords, ...labels]);
+const k = vectors.slice(0, keywords.length);
+const l = vectors.slice(keywords.length);
+const cos = (a, b) => a.reduce((sum, x, i) => sum + x * b[i], 0);
+const rows = labels.map((label, i) => ({
+  label,
+  score: k.reduce((sum, vec) => sum + cos(vec, l[i]), 0) / k.length,
+  per: Object.fromEntries(keywords.map((word, j) => [word, Number(cos(k[j], l[i]).toFixed(3))])),
+})).sort((a, b) => b.score - a.score);
+console.log(JSON.stringify(rows, null, 2));