@kira905/dsh-memory-toolkit 0.0.0-stage → 0.1.1

package/memory-db-tools/_test/test-memory-scope.mjs

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+// tools/memory-db-tools/_test/test-memory-scope.mjs
+//
+// ⑤-3（字段与身份）单测：口径库纯函数 + 库级迁移 + CLI 反向用例（fail-closed 闸门）。
+// 铁律：**全程不碰生产 memory.db**（开测/收尾各比一次 sha 哨兵）；所有库操作都在 os.tmpdir() 里。
+//
+// 跑法：node _test/test-memory-scope.mjs
+// 退出码：0 全绿 / 1 有失败
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { DatabaseSync } from "node:sqlite";
+import { fileURLToPath } from "node:url";
+import {
+  DEFAULT_VISIBILITY,
+  MEMORIES_TABLE,
+  NEW_COLUMNS,
+  VISIBILITY_VALUES,
+  applyMigration,
+  buildAddColumnSql,
+  columnsOf,
+  describeDb,
+  familyScopeSql,
+  hasIndex,
+  isProductionDb,
+  migrationPlan,
+  ownerBindingDiff,
+  ownerScopeSql,
+  parseIdentityTable,
+  productionDbPath,
+  quoteLiteral,
+  readIdentityTable,
+  resolveDefaultOwner,
+  selectMemories,
+  sha256File,
+} from "../lib/memory-scope.mjs";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const TOOLS = path.join(HERE, "..");
+const CLI = {
+  migrate: path.join(TOOLS, "memory-schema-migrate.mjs"),
+  identity: path.join(TOOLS, "memory-identity-check.mjs"),
+  fixture: path.join(TOOLS, "memory-scope-fixture.mjs"),
+  fieldname: path.join(TOOLS, "memory-fieldname-check.mjs"),
+};
+
+let pass = 0;
+const fails = [];
+function ok(name, cond, detail = "") {
+  if (cond) {
+    pass += 1;
+  } else {
+    fails.push(`${name}${detail ? ` —— ${detail}` : ""}`);
+    console.log(`  ✗ ${name}${detail ? ` —— ${detail}` : ""}`);
+  }
+}
+function eq(name, a, b) {
+  ok(name, Object.is(a, b) || JSON.stringify(a) === JSON.stringify(b), `实得 ${JSON.stringify(a)} · 期望 ${JSON.stringify(b)}`);
+}
+function section(t) {
+  console.log(`\n== ${t} ==`);
+}
+
+const PROD = productionDbPath();
+const prodShaBefore = fs.existsSync(PROD) ? sha256File(PROD) : null;
+
+const ROOT = fs.mkdtempSync(path.join(os.tmpdir(), "card053-"));
+const TMP = path.join(ROOT, "sandbox");
+fs.mkdirSync(TMP, { recursive: true });
+
+/** 造一个最小同构库（6 列 + 2 条）。 */
+function makeDb(file) {
+  const db = new DatabaseSync(file);
+  db.exec(`CREATE TABLE ${MEMORIES_TABLE} (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    text TEXT NOT NULL,
+    tags TEXT NOT NULL DEFAULT '',
+    pinned INTEGER NOT NULL DEFAULT 0,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  )`);
+  const ins = db.prepare(`INSERT INTO ${MEMORIES_TABLE} (text, tags, created_at, updated_at) VALUES (?,?,?,?)`);
+  ins.run("第一条", "demo", 1, 1);
+  ins.run("第二条", "demo", 2, 2);
+  db.close();
+  return file;
+}
+const runCli = (script, args, env = {}) =>
+  spawnSync(process.execPath, [script, ...args], { encoding: "utf8", env: { ...process.env, ...env } });
+
+// ---------------------------------------------------------------- ① 纯函数
+section("① 纯函数（身份表解析 / 默认值解析 / DDL / 过滤 SQL）");
+
+{
+  const good = parseIdentityTable(JSON.stringify({ _comment: "注释", LiJianXiao: { role: "owner" }, wife_x: { role: "member" } }));
+  ok("身份表：正常解析", good.ok, good.error || "");
+  eq("身份表：跳过 _ 前缀注释键", good.userids, ["LiJianXiao", "wife_x"]);
+  eq("身份表：取 role=owner", good.owner, "LiJianXiao");
+
+  const bad = parseIdentityTable("{不是 JSON}");
+  ok("身份表：坏 JSON ⇒ ok=false（不抛）", bad.ok === false && bad.userids.length === 0);
+
+  const arr = parseIdentityTable("[1,2]");
+  ok("身份表：数组根 ⇒ ok=false", arr.ok === false);
+
+  const noOwner = resolveDefaultOwner({ ok: true, exists: true, owner: null, userids: ["a"], path: "x" });
+  ok("默认值：无 owner 条目 ⇒ 回落常量 + 有说明行", noOwner.source === "fallback" && noOwner.notes.length > 0);
+  const withOwner = resolveDefaultOwner({ ok: true, exists: true, owner: "LiJianXiao", userids: ["LiJianXiao"], path: "x" });
+  ok("默认值：有 owner 条目 ⇒ 取身份表（非硬编码）", withOwner.ownerUser === "LiJianXiao" && withOwner.source === "identity-table");
+  const broken = resolveDefaultOwner({ ok: false, exists: true, error: "坏了", userids: [], owner: null, path: "x" });
+  ok("默认值：身份表坏 ⇒ 回落 + 报警", broken.source === "fallback" && broken.notes.some((n) => n.includes("不可用")));
+
+  eq("DDL：owner_user", buildAddColumnSql(NEW_COLUMNS[0], "LiJianXiao"), "ALTER TABLE memories ADD COLUMN owner_user TEXT NOT NULL DEFAULT 'LiJianXiao'");
+  eq("DDL：visibility", buildAddColumnSql(NEW_COLUMNS[1], DEFAULT_VISIBILITY), "ALTER TABLE memories ADD COLUMN visibility TEXT NOT NULL DEFAULT 'private_owner'");
+  eq("字面量转义：单引号翻倍", quoteLiteral("O'Brien"), "'O''Brien'");
+  eq("visibility 取值域", [...VISIBILITY_VALUES], ["private_owner", "family", "public"]);
+
+  const fBase = familyScopeSql("wife_x");
+  ok("家人侧基础句 = §3.3-4 原文", fBase.mode === "base" && fBase.where === "(visibility IN ('family','public') OR owner_user = ?)" && fBase.params[0] === "wife_x");
+  const fStrict = familyScopeSql("wife_x", { registeredOwners: ["LiJianXiao", "wife_x", "wife_x"] });
+  ok("家人侧严格句：带已登记护栏且去重", fStrict.mode === "strict" && fStrict.where.includes("owner_user IN (?, ?)") && fStrict.params.length === 3, JSON.stringify(fStrict));
+  const fEmpty = familyScopeSql("wife_x", { registeredOwners: [] });
+  ok("身份表空 ⇒ fail-closed 只留本人条", fEmpty.mode === "strict-empty" && fEmpty.where === "owner_user = ?");
+  let threw = false;
+  try {
+    familyScopeSql(null);
+  } catch {
+    threw = true;
+  }
+  ok("缺 selfUser ⇒ 抛错（不静默放行）", threw);
+
+  eq("主人注入层：默认 owner-only", ownerScopeSql("LiJianXiao").where, "owner_user = ?");
+  ok("主人注入层：可选含共享", ownerScopeSql("LiJianXiao", { includeShared: true }).where.includes("family"));
+
+  ok("生产路径判定：真生产 = true", isProductionDb(PROD));
+  ok("生产路径判定：沙箱 = false", isProductionDb(path.join(ROOT, "sandbox", "memory.db")) === false);
+}
+
+// ---------------------------------------------------------------- ② 库级迁移
+section("② 库级：计划 / 迁移 / 幂等 / 干跑零写入");
+
+{
+  const dbFile = makeDb(path.join(TMP, "t1.db"));
+  const db = new DatabaseSync(dbFile, { readOnly: true });
+  const before = describeDb(db);
+  const plan = migrationPlan(db, { identity: { ok: true, exists: true, owner: "LiJianXiao", userids: ["LiJianXiao"], path: "x" } });
+  db.close();
+  eq("迁移前：6 列", before.columns.length, 6);
+  eq("计划：缺两列", plan.missing, ["owner_user", "visibility"]);
+  eq("计划：3 条语句（两列 + 索引）", plan.statements.length, 3);
+  ok("计划：默认值来自身份表", plan.defaultOwner.source === "identity-table" && plan.statements[0].includes("'LiJianXiao'"));
+
+  const rw = new DatabaseSync(dbFile);
+  const ran = applyMigration(rw, plan);
+  eq("执行：3 条 DDL", ran.length, 3);
+  eq("迁移后：8 列", columnsOf(rw).length, 8);
+  eq("迁移后：条数不变", rw.prepare(`SELECT COUNT(*) c FROM ${MEMORIES_TABLE}`).get().c, 2);
+  ok("迁移后：索引在位", hasIndex(rw, "memories_visibility"));
+  const all = rw.prepare(`SELECT owner_user o, visibility v FROM ${MEMORIES_TABLE}`).all();
+  ok("存量行取默认值（主人私有）", all.every((r) => r.o === "LiJianXiao" && r.v === "private_owner"));
+  const plan2 = migrationPlan(rw, { identity: null });
+  eq("幂等：第二次计划 0 语句", plan2.statements.length, 0);
+  eq("幂等：两列已在位", plan2.present.sort(), ["owner_user", "visibility"]);
+  rw.close();
+
+  // dry-run 零写入（sha 前后一致）
+  const dbFile2 = makeDb(path.join(TMP, "t2.db"));
+  const shaA = sha256File(dbFile2);
+  const r = runCli(CLI.migrate, ["--db", dbFile2, "--json"]);
+  const shaB = sha256File(dbFile2);
+  eq("CLI dry-run：exit 0", r.status, 0);
+  eq("CLI dry-run：源库 sha 未变（零写入）", shaA, shaB);
+  let parsed = null;
+  try {
+    parsed = JSON.parse(r.stdout);
+  } catch {
+    /* 下面断言会报 */
+  }
+  ok("CLI --json：stdout 是纯 JSON（日志不混入 stdout）", Boolean(parsed) && parsed.mode === "dry-run", r.stdout.slice(0, 200));
+  eq("CLI dry-run：列数仍 6", parsed && parsed.before.columns.length, 6);
+
+  // 真改（沙箱路径，无需 --allow-production）
+  const r2 = runCli(CLI.migrate, ["--db", dbFile2, "--apply", "--json"]);
+  eq("CLI apply（沙箱）：exit 0", r2.status, 0);
+  const p2 = JSON.parse(r2.stdout);
+  eq("CLI apply：迁移后 8 列", p2.after.columns.length, 8);
+  ok("CLI apply：条数一致", p2.after.count === p2.before.count);
+  const r3 = runCli(CLI.migrate, ["--db", dbFile2, "--apply", "--json"]);
+  ok("CLI apply：二次幂等（无语句可跑）", r3.status === 0 && JSON.parse(r3.stdout).statementsRan === undefined);
+}
+
+// ---------------------------------------------------------------- ③ CLI 反向用例（fail-closed 闸门）
+section("③ CLI 反向：打生产的三道闸 + 不可用不判过");
+
+{
+  // 伪造 USERPROFILE ⇒ 这个临时库"在 CLI 眼里就是生产库"（真实生产绝不被触碰）
+  const fakeHome = path.join(ROOT, "fakehome");
+  const fakeProdDir = path.join(fakeHome, ".dsh", "memory");
+  fs.mkdirSync(fakeProdDir, { recursive: true });
+  const fakeProd = makeDb(path.join(fakeProdDir, "memory.db"));
+  const sha0 = sha256File(fakeProd);
+
+  const r1 = runCli(CLI.migrate, ["--db", fakeProd, "--apply", "--json"], { USERPROFILE: fakeHome });
+  eq("闸①：打生产未给 --allow-production ⇒ exit 2", r1.status, 2);
+  eq("闸①：库零改动", sha256File(fakeProd), sha0);
+
+  const r2 = runCli(CLI.migrate, ["--db", fakeProd, "--apply", "--allow-production", "--json"], { USERPROFILE: fakeHome });
+  eq("闸②：打生产未给 --snapshot ⇒ exit 2", r2.status, 2);
+  eq("闸②：库零改动", sha256File(fakeProd), sha0);
+
+  const snapDir = path.join(ROOT, "snap");
+  const r3 = runCli(CLI.migrate, ["--db", fakeProd, "--apply", "--allow-production", "--snapshot", snapDir, "--json"], { USERPROFILE: fakeHome });
+  // 闸③ = 停机窗口判据：本机 3080 在跑 ⇒ 应被拒（exit 1）；若恰在停机窗口跑测，则等于放行 —— 两种都记录
+  ok("闸③：停机窗口判据生效（3080 在跑 ⇒ 拒绝）", r3.status === 1 || r3.status === 0, `exit=${r3.status}`);
+  const p3 = JSON.parse(r3.stdout);
+  if (r3.status === 1) {
+    ok("闸③：拒绝理由含停机窗口", String(p3.message).includes("停机窗口"), p3.message);
+    eq("闸③：库零改动（被拒后不写）", sha256File(fakeProd), sha0);
+    ok("闸③：未落快照", !fs.existsSync(path.join(snapDir, "memory.db")));
+  } else {
+    ok("闸③：本次无 DSH 在跑 ⇒ 放行（等价窗口场景）", fs.existsSync(path.join(snapDir, "memory.db")));
+  }
+
+  // --snapshot 但非生产：应正常出快照 + 迁移（沙箱演练路径）
+  const dbS = makeDb(path.join(TMP, "t3.db"));
+  const r4 = runCli(CLI.migrate, ["--db", dbS, "--apply", "--snapshot", path.join(ROOT, "snap2"), "--json"]);
+  eq("沙箱 apply + 快照：exit 0", r4.status, 0);
+  const p4 = JSON.parse(r4.stdout);
+  ok("沙箱 apply：快照条数 = 源库条数", p4.snapshot && p4.snapshot.snapshotCount === p4.before.count);
+  ok("沙箱 apply：快照 sha 已记", typeof p4.snapshot.snapshotSha256 === "string" && p4.snapshot.snapshotSha256.length === 64);
+
+  // 夹具脚本：硬拒绝生产路径
+  const rf = runCli(CLI.fixture, ["--db", fakeProd, "--json"], { USERPROFILE: fakeHome });
+  eq("夹具：打生产路径 ⇒ exit 2（不接受逃生舱）", rf.status, 2);
+  eq("夹具：库零改动", sha256File(fakeProd), sha0);
+
+  // 判据 4：库里没有 owner_user 列 ⇒ exit 2（不可用不判过）
+  const dbNoCol = makeDb(path.join(TMP, "t4.db"));
+  const ri = runCli(CLI.identity, ["--db", dbNoCol, "--users", path.join(ROOT, "none.json"), "--json"]);
+  eq("判据 4：缺列 ⇒ exit 2（不算通过）", ri.status, 2);
+  const dbCol = makeDb(path.join(TMP, "t5.db"));
+  runCli(CLI.migrate, ["--db", dbCol, "--apply", "--json"]);
+  const ri2 = runCli(CLI.identity, ["--db", dbCol, "--users", path.join(ROOT, "none.json"), "--json"]);
+  eq("判据 4：身份表缺位 ⇒ exit 2（不可用不判过）", ri2.status, 2);
+  const usersFile = path.join(ROOT, "users.json");
+  fs.writeFileSync(usersFile, JSON.stringify({ LiJianXiao: { role: "owner" } }), "utf8");
+  const ri3 = runCli(CLI.identity, ["--db", dbCol, "--users", usersFile, "--json"]);
+  eq("判据 4：差集 0 ⇒ exit 0", ri3.status, 0);
+  eq("判据 4：库内 owner 只有主人", JSON.parse(ri3.stdout).diff.owners, ["LiJianXiao"]);
+
+  // 判据 4 反向：造一条未登记 owner
+  const db = new DatabaseSync(dbCol);
+  db.prepare(`INSERT INTO ${MEMORIES_TABLE} (text,tags,created_at,updated_at,owner_user,visibility) VALUES ('x','x',1,1,'ghost_user','private_owner')`).run();
+  db.close();
+  const ri4 = runCli(CLI.identity, ["--db", dbCol, "--users", usersFile, "--json"]);
+  eq("判据 4：未登记 owner ⇒ exit 1（判红）", ri4.status, 1);
+  eq("判据 4：红名单 = ghost_user", JSON.parse(ri4.stdout).diff.unregistered, ["ghost_user"]);
+
+  // 判据 3：白名单不可用 ⇒ exit 2（fail-closed）
+  const rw2 = runCli(CLI.fieldname, ["--whitelist", path.join(ROOT, "no-such-whitelist.json"), "--json"]);
+  eq("判据 3：白名单不可用 ⇒ exit 2（不算通过）", rw2.status, 2);
+
+  // 判据 5 夹具：真跑沙箱库（造 6 条 + 断言）
+  const dbFx = makeDb(path.join(TMP, "t6.db"));
+  runCli(CLI.migrate, ["--db", dbFx, "--apply", "--json"]);
+  const rfx = runCli(CLI.fixture, ["--db", dbFx, "--cleanup", "--json"]);
+  eq("判据 5：夹具全绿 ⇒ exit 0", rfx.status, 0, rfx.stdout.slice(0, 400));
+  const pfx = JSON.parse(rfx.stdout);
+  ok("判据 5：至少 10 条断言且无失败", pfx.assertions.length >= 10 && pfx.failed.length === 0, JSON.stringify(pfx.failed));
+  ok("判据 5：严格模式挡掉超域条（断言在位）", pfx.assertions.some((a) => a.key.includes("超域条") && a.pass));
+  ok("判据 5：基础模式命中超域条被如实登记为已知边界", pfx.knownBoundaries.length === 1);
+  eq("判据 5：--cleanup 清空夹具条", pfx.cleanedUp, 6);
+}
+
+// ---------------------------------------------------------------- ④ 生产哨兵
+section("④ 生产 memory.db 只读哨兵");
+{
+  const prodShaAfter = fs.existsSync(PROD) ? sha256File(PROD) : null;
+  ok("生产库：全程未被本测试触碰（sha 一致）", prodShaBefore === prodShaAfter, `${String(prodShaBefore).slice(0, 12)} vs ${String(prodShaAfter).slice(0, 12)}`);
+  const db = new DatabaseSync(PROD, { readOnly: true });
+  const cols = columnsOf(db);
+  const cnt = (() => { try { return db.prepare(`SELECT COUNT(*) AS c FROM ${MEMORIES_TABLE}`).get().c; } catch { return null; } })();
+  db.close();
+  // ⚠️ 2026-10-11 订正（卡【翻译官·批4·家人档地基】）：本条原写"仍 6 列（本卡未获窗口，不得迁移）"——
+  //    那是 2026-09-20 ⑤-3 卡当时的**绝对断言**，生产库其后**已按口径迁移到 8 列**
+  //    （生产库实测 `PRAGMA table_info(memories)` = 8 列 + 1276 条），该断言因此**过期**、恒红。
+  //    改为**相对断言**（照 dsh-butler §10-③ 的既有做法）：本测试只负责"生产库全程未被本测试触碰"，
+  //    schema 版本另由 `memory-identity-check.mjs` 判 —— 这里只做"没被降级回 6 列"的守门 + 打印现值。
+  ok("生产库：仍是 6 列（本卡未获窗口，不得迁移）", cols.length >= 6, `${cols.length} 列（现值：${cols.join(",")} · ${cnt} 条）`);
+  ok("生产库：两列扩面仍在（owner_user / visibility）", cols.includes("owner_user") && cols.includes("visibility"), cols.join(","));
+}
+
+console.log(`\n==== 单测结果：${pass} 通过 / ${fails.length} 失败 ====`);
+for (const f of fails) console.log(`  ✗ ${f}`);
+try {
+  fs.rmSync(ROOT, { recursive: true, force: true });
+} catch {
+  /* 临时目录清不掉不影响结论 */
+}
+process.exitCode = fails.length ? 1 : 0;

package/memory-db-tools/audit-analyze.mjs

@@ -0,0 +1,352 @@
+#!/usr/bin/env node
+// audit-analyze.mjs — 季度记忆库体检 · 第 2 站：六项分析（消费 memories.json）
+// 固化自早期临时脚本（2026-09-25 体检工具链固化）
+//   · 去硬编码：输入/输出目录改为 --in <memories.json> / --out <dir>，默认落系统临时目录，不再写死 _tmp
+//   · 加 --help / --self-test / --json · 收尾 process.exitCode
+// 产物（6 个）：list-lines.txt（首行清单）· list-nodev.txt（含机器特征词却无【设备：】的候选）·
+//              dup-pairs.txt（重复对，6-gram Jaccard）· keyword-hits.txt（过期关键词命中）·
+//              pinned-full.txt（pinned 全文）· stats.json（统计）
+// 只读：只读 memories.json；不碰 memory.db；产物只写 --out（默认临时目录）。
+
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const SELF = fileURLToPath(import.meta.url);
+export const TOOL = path.basename(SELF);
+
+export function resolveDshHome() {
+  if (process.env.DSH_HOME) return process.env.DSH_HOME;
+  return path.join(process.env.USERPROFILE || os.homedir(), ".dsh");
+}
+export const DSH_HOME = resolveDshHome();
+export const DEFAULT_WORK_DIR = path.join(os.tmpdir(), "dsh-mem-audit");
+export const DEFAULT_IN = path.join(DEFAULT_WORK_DIR, "memories.json");
+
+export function isMainEntry() {
+  const a = process.argv[1];
+  if (!a) return false;
+  try {
+    return fs.realpathSync(a) === fs.realpathSync(SELF);
+  } catch {
+    return false;
+  }
+}
+
+export function parseArgs(argv) {
+  const out = { _: [] };
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--") {
+      out._.push(...argv.slice(i + 1));
+      break;
+    }
+    if (a.startsWith("--")) {
+      const eq = a.indexOf("=");
+      if (eq > 0) out[a.slice(2, eq)] = a.slice(eq + 1);
+      else {
+        const k = a.slice(2);
+        const next = argv[i + 1];
+        if (next !== undefined && !next.startsWith("--")) {
+          out[k] = next;
+          i++;
+        } else out[k] = true;
+      }
+    } else out._.push(a);
+  }
+  return out;
+}
+
+export function makeAsserter() {
+  let pass = 0,
+    total = 0;
+  const fails = [];
+  return {
+    ok(cond, label) {
+      total++;
+      if (cond) pass++;
+      else fails.push(label);
+    },
+    eq(actual, expected, label) {
+      this.ok(actual === expected, `${label}（期望 ${JSON.stringify(expected)}，实际 ${JSON.stringify(actual)}）`);
+    },
+    report() {
+      if (fails.length) {
+        console.log(`[self-test] FAIL  ${pass}/${total}`);
+        for (const f of fails) console.log(`  - ${f}`);
+        return 1;
+      }
+      console.log(`[self-test] PASS  ${pass}/${total}`);
+      return 0;
+    },
+  };
+}
+
+// ---------- 体检口径常量 ----------
+// 「含机器特征词」判据（用于找漏标设备的记忆）。跨机通用：盘符绝对路径 / 用户目录 泛匹配。
+export const MACHINE_RE =
+  /([A-Za-z]:[\\/]|[\\/]Users[\\/][^\\/]+|\.dsh|dsh-|guard|守护鱼|30[89][0-9])/;
+
+// 「过期关键词」扫描表 —— 季度体检口径，过期项增减改这里（真源说明见 README）。
+export const STALE_KEYWORDS = [
+  ["百度盘同步", /百度/],
+  ["坚果云", /坚果云/],
+  ["H盘测试根", /H:[\\/]DSH-test/],
+  ["hold-zstd", /hold-zstd/],
+  ["旧计划任务", /schtasks|计划任务/],
+  ["browser-skill可用", /browser[-_ ]skill/],
+  ["789条旧数", /789/],
+  ["539条旧数", /539/],
+  ["204条旧数", /合并.*204|204 条/],
+  ["百度Sync", /BaiduSync/],
+  ["IPAdapter锁脸", /IPAdapter/],
+  ["LoRA女仆A", /LoRA|女仆A/],
+  ["F盘测试根", /F:[\\/]DSH-test/],
+  ["0.1.1旧主包", /0\.1\.1-rc/],
+  ["3081手机", /3081/],
+  ["Tailscale", /Tailscale/],
+  ["whale-drag补丁", /re-patch-whale-client/],
+  ["notifyRecentWindow旧", /notifyRecentWindow/],
+  ["用户目录下的 .dsh", /[\\/]Users[\\/][^\\/]+[\\/]\.dsh/g],
+];
+
+export function normalizeText(s) {
+  return s
+    .replace(/【设备[：:][^】]*】/g, "")
+    .replace(/\s+/g, "")
+    .replace(/[，。、；：！？（）【】《》“”‘’`\-—…·.,;:!?()\[\]<>"']/g, "");
+}
+
+// ---------- 核心逻辑：纯函数，返回 { files, summary } ----------
+export function analyze(mems, opts = {}) {
+  const K = opts.shingle ?? 6;
+  const minShared = opts.minShared ?? 6;
+  const jacThreshold = opts.jacThreshold ?? 0.15;
+  const byId = new Map(mems.map((m) => [m.id, m]));
+  const files = {};
+
+  // 1) 首行清单
+  const lines = mems.map((m) => {
+    const first = m.text.split("\n")[0].replace(/\s+/g, " ").slice(0, 96);
+    return `#${m.id}${m.pinned ? "*" : ""} ${String(m.text.length).padStart(5)}c ${first}`;
+  });
+  files["list-lines.txt"] = lines.join("\n");
+
+  // 2) 设备标缺失（含机器特征词却无【设备：】）
+  const nodev = mems.filter((m) => !/【设备[：:]/.test(m.text) && MACHINE_RE.test(m.text));
+  files["list-nodev.txt"] = nodev
+    .map((m) => `#${m.id} ${m.text.length}c | ${m.text.split("\n")[0].replace(/\s+/g, " ").slice(0, 110)}`)
+    .join("\n");
+
+  // 3) 重复对（倒排 + Jaccard）
+  const shingles = new Map();
+  for (const m of mems) {
+    const t = normalizeText(m.text);
+    const set = new Set();
+    for (let i = 0; i + K <= t.length; i++) set.add(t.slice(i, i + K));
+    if (t.length < K) set.add(t);
+    shingles.set(m.id, set);
+  }
+  const inv = new Map();
+  for (const [id, set] of shingles) {
+    for (const s of set) {
+      let arr = inv.get(s);
+      if (!arr) inv.set(s, (arr = []));
+      if (arr.length < 25) arr.push(id);
+    }
+  }
+  const pairCount = new Map();
+  for (const arr of inv.values()) {
+    if (arr.length < 2) continue;
+    for (let i = 0; i < arr.length; i++)
+      for (let j = i + 1; j < arr.length; j++) {
+        const key = arr[i] < arr[j] ? `${arr[i]}|${arr[j]}` : `${arr[j]}|${arr[i]}`;
+        pairCount.set(key, (pairCount.get(key) ?? 0) + 1);
+      }
+  }
+  const pairs = [];
+  for (const [key, c] of pairCount) {
+    if (c < minShared) continue;
+    const [a, b] = key.split("|").map(Number);
+    const A = shingles.get(a),
+      B = shingles.get(b);
+    let inter = 0;
+    for (const s of A) if (B.has(s)) inter++;
+    const jac = inter / (A.size + B.size - inter);
+    if (jac >= jacThreshold) pairs.push({ a, b, jac: Number(jac.toFixed(3)), inter });
+  }
+  pairs.sort((x, y) => y.jac - x.jac);
+  files["dup-pairs.txt"] = pairs
+    .map((p) => {
+      const A = byId.get(p.a),
+        B = byId.get(p.b);
+      return `${p.jac} #${p.a}(${A.text.length}c${A.pinned ? ",P" : ""}) <> #${p.b}(${B.text.length}c${B.pinned ? ",P" : ""}) | ${A.text.split("\n")[0].slice(0, 60)} || ${B.text.split("\n")[0].slice(0, 60)}`;
+    })
+    .join("\n");
+
+  // 4) 过期关键词扫描
+  const hits = [];
+  for (const [name, re] of STALE_KEYWORDS) {
+    const ids = mems.filter((m) => re.test(m.text)).map((m) => m.id);
+    hits.push(`${name} (${ids.length}): ${ids.join(",")}`);
+  }
+  files["keyword-hits.txt"] = hits.join("\n\n");
+
+  // 5) pinned 全文
+  const pinned = mems.filter((m) => m.pinned);
+  files["pinned-full.txt"] = pinned.map((m) => `=== #${m.id} (${m.text.length}c) ===\n${m.text}`).join("\n\n");
+
+  // 6) 统计
+  const stats = {
+    total: mems.length,
+    pinned: pinned.length,
+    chars: mems.reduce((s, m) => s + m.text.length, 0),
+    pinnedChars: pinned.reduce((s, m) => s + m.text.length, 0),
+    nodevCount: nodev.length,
+    dupPairCount: pairs.length,
+    topDup: pairs.slice(0, 40),
+    pinnedSizes: pinned.map((m) => ({ id: m.id, chars: m.text.length })),
+    longNonPinned: mems
+      .filter((m) => !m.pinned)
+      .sort((a, b) => b.text.length - a.text.length)
+      .slice(0, 15)
+      .map((m) => ({ id: m.id, chars: m.text.length, head: m.text.split("\n")[0].slice(0, 70) })),
+  };
+  files["stats.json"] = JSON.stringify(stats, null, 1);
+
+  const summary = {
+    lines: lines.length,
+    nodev: nodev.length,
+    dupPairs: pairs.length,
+    pinned: pinned.length,
+    pinnedChars: stats.pinnedChars,
+    topDup: pairs.slice(0, 10).map((p) => `${p.jac}:${p.a}<>${p.b}`),
+  };
+  return { files, summary, stats };
+}
+
+const USAGE = `audit-analyze.mjs — 季度记忆库体检 · 第 2 站：六项分析（消费 memories.json）
+
+用法：
+  node ${TOOL} [--in <memories.json>] [--out <dir>] [--json] [--quiet]
+  node ${TOOL} --help
+  node ${TOOL} --self-test
+
+参数：
+  --in <file>    记忆导出 JSON，默认 ${DEFAULT_IN}（由 audit-export.mjs 产出）
+  --out <dir>    6 个产物的输出目录，默认 = --in 所在目录
+  --json         以 JSON 输出摘要
+  --quiet        不打印摘要
+
+产物（写在 --out 下）：
+  list-lines.txt   全部条目首行清单
+  list-nodev.txt   含机器特征词但无【设备：】的漏标候选
+  dup-pairs.txt    重复对（6-gram Jaccard ≥ 0.15）
+  keyword-hits.txt 19 组过期关键词命中 id
+  pinned-full.txt  pinned 全文
+  stats.json       统计（总数/pinned/字符数/最长非 pinned/topDup）
+
+退出码：
+  0  成功
+  1  --self-test 断言失败
+  2  用法错误
+  3  输入文件不存在
+  4  运行错误（JSON 解析失败等）
+
+只读：只读 memories.json，不碰 memory.db；产物只写 --out（默认临时目录，不落生产路径）。
+`;
+
+export function main(argv = process.argv.slice(2)) {
+  const a = parseArgs(argv);
+  if (a.help) {
+    console.log(USAGE);
+    return 0;
+  }
+  if (typeof a["self-test"] !== "undefined") return selfTest();
+
+  const inFile = typeof a.in === "string" ? path.resolve(a.in) : DEFAULT_IN;
+  if (!fs.existsSync(inFile)) {
+    console.error(`[${TOOL}] 输入不存在：${inFile}（先跑 audit-export.mjs，或用 --in 指定）`);
+    return 3;
+  }
+  const outDir = typeof a.out === "string" ? path.resolve(a.out) : path.dirname(inFile);
+  const mems = JSON.parse(fs.readFileSync(inFile, "utf8"));
+  const { files, summary } = analyze(mems);
+
+  fs.mkdirSync(outDir, { recursive: true });
+  for (const [name, content] of Object.entries(files)) fs.writeFileSync(path.join(outDir, name), content, "utf8");
+
+  if (a.json) {
+    console.log(JSON.stringify({ in: inFile, outDir, ...summary }, null, 1));
+    return 0;
+  }
+  if (a.quiet !== true) {
+    console.log(`IN=${inFile}  OUT=${outDir}`);
+    console.log(
+      `lines=${summary.lines} nodev=${summary.nodev} dupPairs=${summary.dupPairs} pinned=${summary.pinned} pinnedChars=${summary.pinnedChars}`,
+    );
+    console.log("top dup: " + summary.topDup.join(" "));
+  }
+  return 0;
+}
+
+// ---------- self-test（无副作用：合成 JSON + 临时输出目录） ----------
+export function selfTest() {
+  const t = makeAsserter();
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "audit-analyze-selftest-"));
+  const inFile = path.join(tmp, "memories.json");
+  const outDir = path.join(tmp, "out");
+  try {
+    const base = "【设备：ROG】重复内容判定用长文本片段甲乙丙丁戊己庚辛壬癸子丑寅卯辰巳午未申酉戌亥";
+    const DRV = path.parse(process.cwd()).root;
+    const mems = [
+      { id: 1, text: base, pinned: true, tags: "", created_at: 1, updated_at: 1 },
+      { id: 2, text: base + "尾巴", pinned: false, tags: "", created_at: 1, updated_at: 1 },
+      { id: 3, text: `无设备标但提到 ${DRV}work 与 3080 的条目`, pinned: false, tags: "", created_at: 1, updated_at: 1 },
+      { id: 4, text: "这是一条提到坚果云的过期记忆", pinned: false, tags: "", created_at: 1, updated_at: 1 },
+    ];
+    fs.writeFileSync(inFile, JSON.stringify(mems), "utf8");
+    const before = fs.readFileSync(inFile, "utf8");
+
+    const { files, summary } = analyze(mems);
+    t.eq(summary.lines, 4, "首行清单条数");
+    t.eq(summary.pinned, 1, "pinned 条数");
+    t.eq(files["list-lines.txt"].split("\n").length, 4, "list-lines 行数");
+    t.ok(files["list-nodev.txt"].includes("#3"), "漏标候选命中 #3（含盘符绝对路径）");
+    t.ok(!files["list-nodev.txt"].includes("#1"), "已带设备标的 #1 不入漏标候选");
+    t.ok(summary.dupPairs >= 1, "近似重复对 >= 1");
+    t.ok(files["dup-pairs.txt"].includes("#1") && files["dup-pairs.txt"].includes("#2"), "重复对指向 #1<>#2");
+    t.ok(/坚果云 \(1\): 4/.test(files["keyword-hits.txt"]), "过期关键词「坚果云」命中 #4");
+    t.ok(files["pinned-full.txt"].includes("=== #1"), "pinned 全文含 #1");
+    const stats = JSON.parse(files["stats.json"]);
+    t.eq(stats.total, 4, "stats.total");
+    t.eq(stats.pinnedChars, base.length, "stats.pinnedChars");
+
+    // 写产物（临时目录）并验证
+    fs.mkdirSync(outDir, { recursive: true });
+    for (const [name, content] of Object.entries(files)) fs.writeFileSync(path.join(outDir, name), content, "utf8");
+    t.eq(fs.readdirSync(outDir).length, 6, "产物文件数 = 6");
+
+    // 自证只读
+    t.eq(fs.readFileSync(inFile, "utf8"), before, "输入 JSON 前后字节一致（未写输入）");
+    const src = fs.readFileSync(SELF, "utf8");
+    const body = src.split("// ---------- self-test")[0];
+    t.ok(!/fs\.writeFileSync/.test(body.split("export function analyze")[0]), "核心分析函数之前不含 fs.writeFileSync");
+    t.ok(!/new DatabaseSync\(/.test(body), "主体逻辑段不开放任何数据库（纯 JSON 只读）");
+  } catch (e) {
+    t.ok(false, `self-test 抛错：${e?.message ?? e}`);
+  } finally {
+    fs.rmSync(tmp, { recursive: true, force: true });
+  }
+  return t.report();
+}
+
+if (isMainEntry()) {
+  try {
+    process.exitCode = main();
+  } catch (e) {
+    console.error(`[${TOOL}] 运行错误：${e?.stack ?? e}`);
+    process.exitCode = 4;
+  }
+}