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

package/bin/extraction_service.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+"""One-shot extraction service: stdin {text}, stdout {ok, lang, entities, slots}."""
+import json
+import os
+import sys
+
+import torch
+from transformers import AutoModelForTokenClassification, AutoTokenizer
+
+sys.stdout.reconfigure(encoding="utf-8")
+sys.stderr.reconfigure(encoding="utf-8")
+
+ZH_MODEL = os.environ.get("ZH_MODEL_DIR", "uer/roberta-base-finetuned-cluener2020-chinese")
+EN_MODEL = os.environ.get("EN_MODEL_DIR", "elastic/distilbert-base-uncased-finetuned-conll03-english")
+ZH_SLOT = {
+    "name": "characters", "address": "location", "scene": "location",
+    "company": "objects", "organization": "objects", "government": "objects",
+    "book": "objects", "movie": "objects", "game": "objects",
+}
+EN_SLOT = {"PER": "characters", "LOC": "location", "ORG": "objects", "MISC": "objects"}
+
+torch.set_num_threads(1)
+zh_tok = AutoTokenizer.from_pretrained(ZH_MODEL)
+zh_model = AutoModelForTokenClassification.from_pretrained(ZH_MODEL, local_files_only=True, use_safetensors=False)
+zh_model.eval()
+en_tok = AutoTokenizer.from_pretrained(EN_MODEL)
+en_model = AutoModelForTokenClassification.from_pretrained(EN_MODEL, local_files_only=True, use_safetensors=False)
+en_model.eval()
+
+
+def route(text):
+    cjk = sum(1 for c in text if "\u4e00" <= c <= "\u9fff")
+    latin = sum(1 for c in text if c.isascii() and c.isalpha())
+    return "en" if cjk == 0 and latin > 0 else "zh"
+
+
+def infer(tok, model, text, mode):
+    enc = tok(text, return_tensors="pt", truncation=True, max_length=256, return_offsets_mapping=True)
+    offsets = enc.pop("offset_mapping")[0].tolist()
+    with torch.no_grad():
+        ids = model(**enc).logits[0].argmax(-1).tolist()
+    if os.environ.get("DEBUG_EXTRACTION"):
+        global DEBUG_LAST
+        DEBUG_LAST = {
+            "tokens": tok.convert_ids_to_tokens(enc["input_ids"][0])[:12],
+            "pred": [model.config.id2label[int(i)] for i in ids[:12]],
+        }
+    entities = []
+    current = None
+    for idx, label_id in enumerate(ids):
+        label = model.config.id2label[int(label_id)]
+        start, end = offsets[idx]
+        if start == end:
+            continue
+        if label == "O":
+            if current:
+                entities.append(current)
+                current = None
+            continue
+        prefix, _, kind = label.partition("-")
+        if mode == "zh":
+            if prefix == "S":
+                if current:
+                    entities.append(current)
+                entities.append({"text": text[start:end], "label": kind, "start": start, "end": end})
+                current = None
+            elif prefix == "B":
+                if current:
+                    entities.append(current)
+                current = {"text": text[start:end], "label": kind, "start": start, "end": end}
+            elif prefix in ("I", "E") and current:
+                current["text"] += text[start:end]
+                current["end"] = end
+                if prefix == "E":
+                    entities.append(current)
+                    current = None
+        else:
+            if prefix == "B":
+                if current:
+                    entities.append(current)
+                current = {"text": text[start:end], "label": kind, "start": start, "end": end}
+            elif prefix == "I" and current and current["label"] == kind:
+                current["text"] += text[start:end]
+                current["end"] = end
+            else:
+                if current:
+                    entities.append(current)
+                current = {"text": text[start:end], "label": kind, "start": start, "end": end}
+    if current:
+        entities.append(current)
+    if mode == "en":
+        merged = []
+        for entity in entities:
+            last = merged[-1] if merged else None
+            if last and last["label"] == entity["label"] and entity["start"] - last["end"] <= 1:
+                last["text"] += entity["text"]
+                last["end"] = entity["end"]
+            else:
+                merged.append(entity)
+        entities = merged
+    return entities
+
+
+def extract(text):
+    lang = route(text)
+    zh_entities = infer(zh_tok, zh_model, text, "zh")
+    en_entities = infer(en_tok, en_model, text, "en")
+    if os.environ.get("DEBUG_EXTRACTION"):
+        print("DEBUG", repr(text[:20]), zh_model.config.id2label, zh_entities[:3], file=sys.stderr)
+    combined = []
+    seen = set()
+    for entity in en_entities:
+        if any(c.isascii() and c.isalpha() for c in entity["text"]):
+            key = (entity["start"], entity["end"], entity["text"])
+            if key not in seen:
+                seen.add(key)
+                combined.append(entity)
+    for entity in zh_entities:
+        if not any(c.isascii() and c.isalpha() for c in entity["text"]):
+            key = (entity["start"], entity["end"], entity["text"])
+            if key not in seen:
+                seen.add(key)
+                combined.append(entity)
+    combined.sort(key=lambda item: (item["start"], item["end"]))
+    slot_map = {**ZH_SLOT, **EN_SLOT}
+    slots = {"characters": [], "location": None, "objects": []}
+    for entity in combined:
+        slot = slot_map.get(entity["label"])
+        if slot == "characters":
+            slots["characters"].append(entity["text"])
+        elif slot == "location" and slots["location"] is None:
+            slots["location"] = entity["text"]
+        elif slot == "objects":
+            slots["objects"].append(entity["text"])
+    slots["characters"] = list(dict.fromkeys(slots["characters"]))
+    slots["objects"] = list(dict.fromkeys(slots["objects"]))
+    slots["objects"] = [item for item in slots["objects"] if item not in slots["characters"]]
+    debug = None
+    if os.environ.get("DEBUG_EXTRACTION"):
+        debug = {"text": text[:40], "zh_entities": zh_entities[:5], "labels": [zh_model.config.id2label[i] for i in range(4)], "last": DEBUG_LAST}
+    return {"lang": lang, "entities": combined, "slots": slots, "debug": debug}
+
+
+def handle(request):
+    if request.get("health"):
+        return {"ok": True, "health": "ready", "langs": ["zh", "en"]}
+    try:
+        return {"ok": True, **extract(str(request.get("text", "")))}
+    except Exception as error:
+        return {"ok": False, "reason": type(error).__name__, "message": str(error)[:300]}
+
+
+if "--serve" in sys.argv:
+    for raw in sys.stdin.buffer:
+        line = raw.decode("utf-8", "replace").strip()
+        if not line:
+            continue
+        request = json.loads(line)
+        result = {"id": request.get("id"), **handle(request)}
+        print(json.dumps(result, ensure_ascii=False), flush=True)
+else:
+    request = json.loads(sys.stdin.buffer.read().decode("utf-8"))
+    print(json.dumps(handle(request), ensure_ascii=False))

package/bin/facet-active-experiment.mjs

@@ -0,0 +1,110 @@
+#!/usr/bin/env node
+/**
+ * Active-learning label-efficiency experiment.
+ *
+ * Select 10 labels from a train pool (no test leakage), compare random vs
+ * uncertainty selection, then evaluate the untouched test pool.
+ */
+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');
+if (!input) {
+  console.error('usage: node bin/facet-active-experiment.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 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 vectorOf = new Map(rows.map((row, index) => [row.turn, vectors[index]]));
+
+function makeLearner(selected) {
+  const learner = new OnlineFacetKnn({ k: 5, minSimilarity: 0.15, minVote: 0.5 });
+  for (const row of selected) learner.add(vectorOf.get(row.turn), row.facets);
+  return learner;
+}
+
+function evaluate(selected) {
+  const learner = makeLearner(selected);
+  const report = Object.fromEntries(SLOTS.map((slot) => [slot, { total: 0, covered: 0, correct: 0 }]));
+  for (const row of test) {
+    const truth = normalizeFacets(row.facets ?? {});
+    const predicted = learner.predict(vectorOf.get(row.turn));
+    predicted.facets.random = detectRandom(row.text).value;
+    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;
+    }
+  }
+  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;
+}
+
+function uncertainty(learner, vector) {
+  const predicted = learner.predict(vector);
+  const slots = ['activity', 'topic'];
+  let sum = 0;
+  for (const slot of slots) {
+    const confidence = predicted.confidence?.[slot];
+    sum += confidence === undefined ? 1 : 1 - confidence;
+  }
+  return sum / slots.length;
+}
+
+function activeSelect(seedCount, budget) {
+  const selected = [...train.slice(0, seedCount)];
+  const pool = train.slice(seedCount);
+  while (selected.length < budget && pool.length > 0) {
+    const learner = makeLearner(selected);
+    let bestIndex = 0;
+    let best = -1;
+    pool.forEach((row, index) => {
+      const score = uncertainty(learner, vectorOf.get(row.turn));
+      if (score > best) { best = score; bestIndex = index; }
+    });
+    selected.push(pool.splice(bestIndex, 1)[0]);
+  }
+  return selected;
+}
+
+function randomSelect(seedCount, budget) {
+  return train.slice(0, Math.min(budget, train.length));
+}
+
+const result = {
+  full: evaluate(train),
+  random10: evaluate(randomSelect(2, 10)),
+  active10: evaluate(activeSelect(2, 10)),
+  random20: evaluate(randomSelect(2, 20)),
+  active20: evaluate(activeSelect(2, 20)),
+};
+fs.writeFileSync(`${input}.active-experiment.json`, `${JSON.stringify(result, null, 2)}\n`, 'utf8');
+const summary = Object.fromEntries(Object.entries(result).map(([name, report]) => [name, Object.fromEntries(Object.entries(report).map(([slot, row]) => [slot, `${(row.accuracy * 100).toFixed(1)}% @ ${(row.coverage * 100).toFixed(1)}%`]))]));
+console.log(JSON.stringify(summary, null, 2));

package/bin/facet-covid.mjs

@@ -0,0 +1,8 @@
+import fs from 'node:fs';
+import { deserializePrototypes, predictEmbedding } from '../src/facets/embedding.mjs';
+import { extractFacets } from '../src/facets/extract.mjs';
+
+const text = '我昨天看了COVID-19的起源报告，病毒可能来自实验室泄漏，也提到自然宿主和冷链传播。';
+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 result = await predictEmbedding(prototypes, text);
+console.log(JSON.stringify({ text, rule: extractFacets(text), embedding: result }, null, 2));

package/bin/facet-curve.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+/**
+ * Facet sensitivity CLI: rows with facets -> weighted temporal curve.
+ */
+import fs from 'node:fs';
+import { buildFacetIndex } from '../src/facets/index.mjs';
+import { sensitivitySeries } from '../src/facets/sensitivity.mjs';
+import { aliasFacets } 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-curve.mjs --input rows.jsonl --query 跑团 [--out series.json]');
+  process.exit(2);
+}
+const rows = fs.readFileSync(input, 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+const index = buildFacetIndex(rows);
+const series = sensitivitySeries(index.entries, aliasFacets(query), { idf: index.idf });
+const out = argOf('--out');
+const text = JSON.stringify({ query, facets: aliasFacets(query), series }, null, 2);
+if (out) fs.writeFileSync(out, `${text}\n`, 'utf8');
+else console.log(text);

package/bin/facet-embedding-train.mjs

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { buildEmbeddingPrototypes, serializePrototypes } 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 input = argOf('--input');
+const out = argOf('--out') ?? 'facet-prototypes.json';
+const model = argOf('--model') ?? 'Xenova/bge-small-zh-v1.5';
+if (!input) {
+  console.error('usage: node bin/facet-embedding-train.mjs --input rows.jsonl --out facet-prototypes.json');
+  process.exit(2);
+}
+const rows = fs.readFileSync(input, 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+const prototypes = await buildEmbeddingPrototypes(rows, model);
+fs.writeFileSync(out, `${JSON.stringify(serializePrototypes(prototypes))}\n`, 'utf8');
+console.log(JSON.stringify({ input: rows.length, out, model }, null, 2));

package/bin/facet-embedding-validate.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+/**
+ * Embedding holdout validation.
+ *
+ * node bin/facet-embedding-validate.mjs --input rows.jsonl
+ *
+ * Requires @huggingface/transformers and a first-run model download (local
+ * cache afterwards). No text leaves the machine after the model is cached.
+ */
+import fs from 'node:fs';
+import { buildEmbeddingPrototypes, predictEmbedding } from '../src/facets/embedding.mjs';
+import { trainFacetClassifier } from '../src/facets/classifier.mjs';
+import { hybridExtractor } from '../src/facets/hybrid.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-embedding-validate.mjs --input rows.jsonl [--model ...]');
+  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 prototypes = await buildEmbeddingPrototypes(train, model);
+const fallback = hybridExtractor(trainFacetClassifier(train));
+
+function emptyReport() {
+  return Object.fromEntries(SLOTS.map((slot) => [slot, { total: 0, covered: 0, correct: 0 }]));
+}
+const embedReport = emptyReport();
+const mergedReport = emptyReport();
+for (const row of test) {
+  const truth = normalizeFacets(row.facets ?? {});
+  const embedded = await predictEmbedding(prototypes, row.text, model);
+  const merged = fallback(row.text);
+  for (const slot of SLOTS) {
+    if (truth[slot] === undefined) continue;
+    embedReport[slot].total += 1;
+    mergedReport[slot].total += 1;
+    if (embedded.facets[slot] !== undefined) {
+      embedReport[slot].covered += 1;
+      if (embedded.facets[slot] === truth[slot]) embedReport[slot].correct += 1;
+    }
+    const predicted = embedded.facets[slot] ?? merged.facets[slot];
+    if (predicted !== undefined) {
+      mergedReport[slot].covered += 1;
+      if (predicted === truth[slot]) mergedReport[slot].correct += 1;
+    }
+  }
+}
+
+function finish(report) {
+  return Object.fromEntries(Object.entries(report).map(([slot, value]) => [slot, {
+    ...value,
+    coverage: value.total === 0 ? 0 : value.covered / value.total,
+    accuracy: value.covered === 0 ? 0 : value.correct / value.covered,
+  }]));
+}
+
+console.log(JSON.stringify({
+  model,
+  split: { train: train.length, test: test.length },
+  embeddingOnly: finish(embedReport),
+  embeddingWithNBFallback: finish(mergedReport),
+}, null, 2));

package/bin/facet-eval-roleplay.mjs

@@ -0,0 +1,42 @@
+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))
+  .filter((row) => row.facets?.activity === '跑团');
+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 slots = ['activity', 'interaction', 'random', 'participants', 'medium', 'topic'];
+const report = { total: rows.length, methods: {} };
+const examples = [];
+for (const [name, method] of [['rule', (text) => extractFacets(text)], ['nb', (text) => predictFacets(nb, text)], ['embedding', async (text) => predictEmbedding(prototypes, text)]]) {
+  const stats = Object.fromEntries(slots.map((slot) => [slot, { total: 0, covered: 0, correct: 0 }]));
+  let exact = 0;
+  for (const row of rows) {
+    const prediction = await method(row.text);
+    let all = true;
+    for (const slot of slots) {
+      const truth = row.facets?.[slot];
+      if (truth === undefined) { all = false; continue; }
+      stats[slot].total += 1;
+      const predicted = prediction.facets?.[slot];
+      if (predicted === undefined) { all = false; continue; }
+      stats[slot].covered += 1;
+      if (predicted === truth) stats[slot].correct += 1;
+      else all = false;
+    }
+    if (all) exact += 1;
+    if (name === 'embedding' && examples.length < 8) examples.push({ turn: row.turn, truth: row.facets, predicted: prediction.facets, text: String(row.text).replace(/\s+/g, ' ').slice(0, 180) });
+  }
+  for (const slot of slots) {
+    const s = stats[slot];
+    s.coverage = s.total === 0 ? 0 : Number((s.covered / s.total).toFixed(3));
+    s.accuracy = s.covered === 0 ? 0 : Number((s.correct / s.covered).toFixed(3));
+  }
+  report.methods[name] = { slots: stats, exactFull: Number((exact / rows.length).toFixed(3)) };
+}
+report.examples = examples;
+fs.writeFileSync('C:/Users/35794/Documents/DeepSeek\'s Sandbox/coopanion-continuity/backups/continuity-tags-20261031/durable-memory/build-a/FACET-EVAL-ROLEPLAY.json', JSON.stringify(report, null, 2));
+console.log(JSON.stringify(report, null, 2));

package/bin/facet-eval.mjs

@@ -0,0 +1,38 @@
+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)).filter((row) => row.facets && row.text);
+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 slots = ['activity', 'interaction', 'random', 'participants', 'medium', 'topic'];
+const report = { total: rows.length, methods: {} };
+for (const [name, method] of [['rule', (text) => extractFacets(text)], ['nb', (text) => predictFacets(nb, text)], ['embedding', async (text) => predictEmbedding(prototypes, text)]]) {
+  const stats = Object.fromEntries(slots.map((slot) => [slot, { total: 0, covered: 0, correct: 0 }]));
+  let exact = 0;
+  for (const row of rows) {
+    const prediction = await method(row.text);
+    let all = true;
+    for (const slot of slots) {
+      const truth = row.facets?.[slot];
+      if (truth === undefined) { all = false; continue; }
+      stats[slot].total += 1;
+      const predicted = prediction.facets?.[slot];
+      if (predicted === undefined) { all = false; continue; }
+      stats[slot].covered += 1;
+      if (predicted === truth) stats[slot].correct += 1;
+      else all = false;
+    }
+    if (all) exact += 1;
+  }
+  for (const slot of slots) {
+    const s = stats[slot];
+    s.coverage = s.total === 0 ? 0 : Number((s.covered / s.total).toFixed(3));
+    s.accuracy = s.covered === 0 ? 0 : Number((s.correct / s.covered).toFixed(3));
+  }
+  report.methods[name] = { slots: stats, exactFull: Number((exact / rows.length).toFixed(3)) };
+}
+fs.writeFileSync('C:/Users/35794/Documents/DeepSeek\'s Sandbox/coopanion-continuity/backups/continuity-tags-20261031/durable-memory/build-a/FACET-EVAL-1462.json', JSON.stringify(report, null, 2));
+console.log(JSON.stringify(report, null, 2));

package/bin/facet-fold.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { buildFacetIndex } from '../src/facets/index.mjs';
+import { aliasFacets } 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 out = argOf('--out');
+const query = argOf('--query') ?? '跑团';
+if (!input || !out) {
+  console.error('usage: node bin/facet-fold.mjs --input rows.jsonl --out facet-fold.json --query 跑团');
+  process.exit(2);
+}
+const rows = fs.readFileSync(input, 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+const index = buildFacetIndex(rows);
+const payload = {
+  query: aliasFacets(query),
+  idf: [...index.idf.entries()],
+  entries: index.entries.map((entry) => ({
+    turn: entry.turn,
+    seqStart: entry.seqStart,
+    seqEnd: entry.seqEnd,
+    facets: entry.facets,
+  })),
+};
+fs.writeFileSync(out, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+console.log(JSON.stringify({ out, query, entries: payload.entries.length }, null, 2));

package/bin/facet-load.mjs

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+import { loadFacetQuery } from '../src/facets/load.mjs';
+
+const args = process.argv.slice(2);
+const argOf = (name) => {
+  const i = args.indexOf(name);
+  return i >= 0 ? args[i + 1] : undefined;
+};
+const query = argOf('--query') ?? '跑团';
+const indexFile = argOf('--index');
+if (!indexFile) {
+  console.error('usage: node bin/facet-load.mjs --index facet-index.json --query 跑团 [--top 20]');
+  process.exit(2);
+}
+const topK = Number(argOf('--top') ?? 20);
+console.log(JSON.stringify(loadFacetQuery(query, { indexFile, topK }), null, 2));

package/bin/facet-mlp-scan.mjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import { deserializeMlp, predictMlp } from '../src/facets/mlp-probe.mjs';
+import { embedTexts } from '../src/facets/embedding.mjs';
+import { detectRandom } from '../src/facets/random.mjs';
+import { buildFacetIndex, queryFacets, indexStats } from '../src/facets/index.mjs';
+import { saveIndex } from '../src/facets/store.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 modelPath = argOf('--model');
+const dir = argOf('--dir') ?? '.facet-mlp';
+const query = argOf('--query') ?? '跑团';
+if (!input || !modelPath) {
+  console.error('usage: node bin/facet-mlp-scan.mjs --input rows.jsonl --model MLP-MODEL.json --dir .facet --query 跑团');
+  process.exit(2);
+}
+const rows = fs.readFileSync(input, 'utf8').split(/\r?\n/).filter(Boolean).map((line) => JSON.parse(line));
+const model = deserializeMlp(JSON.parse(fs.readFileSync(modelPath, 'utf8')));
+const entries = [];
+for (const row of rows) {
+  const [vector] = await embedTexts([row.text]);
+  const result = predictMlp(model, vector);
+  result.facets.random = detectRandom(row.text).value;
+  if (result.facets.participants === undefined) result.facets.participants = '协作';
+  entries.push({
+    turn: row.turn,
+    seqStart: row.seqStart,
+    seqEnd: row.seqEnd,
+    facets: result.facets,
+    confidence: result.confidence,
+  });
+}
+const index = buildFacetIndex(entries);
+fs.mkdirSync(dir, { recursive: true });
+saveIndex(`${dir}/facet-index.json`, index);
+const result = queryFacets(index, query, { topK: rows.length });
+console.log(JSON.stringify({
+  stats: indexStats(index),
+  query: { name: result.query, facets: result.facets, matches: result.matches.length, ranges: result.ranges },
+}, null, 2));

package/bin/facet-mvp.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * Facet MVP CLI.
+ *
+ * Input JSONL rows: { turn, seqStart, seqEnd, text? , facets? }
+ * Builds a facet index, prints stats, and runs one alias query.
+ */
+import fs from 'node:fs';
+import { buildFacetIndex, indexStats, queryFacets } from '../src/facets/index.mjs';
+
+const args = process.argv.slice(2);
+const argOf = (name) => {
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] : undefined;
+};
+const input = argOf('--input');
+const query = argOf('--query') ?? '跑团';
+const topK = Number(argOf('--top')) || 20;
+if (!input) {
+  console.error('usage: node bin/facet-mvp.mjs --input rows.jsonl --query 跑团 [--top 20]');
+  process.exit(2);
+}
+const rows = fs.readFileSync(input, 'utf8')
+  .split(/\r?\n/).filter(Boolean)
+  .map((line) => JSON.parse(line));
+const index = buildFacetIndex(rows);
+const result = queryFacets(index, query, { topK });
+console.log(JSON.stringify({
+  stats: indexStats(index),
+  query: { name: result.query, facets: result.facets },
+  matchCount: result.matches.length,
+  ranges: result.ranges,
+  top: result.matches.slice(0, Math.min(10, topK)),
+}, null, 2));