@modusensus/dsh-mneme 0.9.0 → 0.9.1

package/test/persona-api.test.js

@@ -0,0 +1,172 @@
+// Persona API routes: internal (/api/dsh-mneme/persona, requireAuth on write)
+// and standalone (/persona behind the global Bearer gate).
+// Locks: GET reads current value; unauthorized writes are rejected; a corrupt
+// JSON body never lands in the store (design: reports/persona-page-design.md ②).
+// Call shapes mirror test/api.test.js (route registry + FakeRes) and
+// test/standalone-api.test.js (real server on port 0 + fetch).
+import test from "node:test";
+import assert from "node:assert/strict";
+import { EventEmitter } from "node:events";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createApi } from "../src/api.js";
+import { createSettings } from "../src/settings.js";
+import { createStandaloneApi } from "../src/api-standalone.js";
+
+class FakeRes extends EventEmitter {
+  constructor() { super(); this.statusCode = 200; this.body = ""; }
+  writeHead(code, headers) { this.statusCode = code; this.headers = headers; return this; }
+  end(text) { this.body = text ?? ""; this.emit("end"); return this; }
+}
+
+function req(path, method = "GET", body = null, headers = {}) {
+  const r = new EventEmitter();
+  r.url = path;
+  r.method = method;
+  r.headers = headers;
+  if (body !== null) {
+    process.nextTick(() => {
+      r.emit("data", Buffer.from(typeof body === "string" ? body : JSON.stringify(body)));
+      r.emit("end");
+    });
+  }
+  return r;
+}
+
+function setupInternal(apiToken = "") {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const commands = {
+    add: (def) => settings.addCommand(def),
+    remove: (id) => settings.removeCommand(id),
+    list: () => settings.listCommands()
+  };
+  const routes = [];
+  const ctx = {
+    webServer: {
+      register(route) {
+        routes.push(route);
+        return () => {};
+      }
+    }
+  };
+  createApi(ctx, service, settings, commands, undefined, undefined, apiToken, {});
+  const route = routes.find((r) => r.path === "/api/dsh-mneme/persona");
+  return { store, settings, route, apiToken };
+}
+
+// ---- internal API（宿主内 /api/dsh-mneme/*） --------------------------------
+
+test("internal GET /persona returns current persona without auth", async () => {
+  const { store, settings, route } = setupInternal();
+  settings.setPersona({ name: "Amarre", enabled: false });
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/persona"), res);
+  assert.equal(res.statusCode, 200);
+  assert.equal(JSON.parse(res.body).persona.default.name, "Amarre");
+  store.close();
+});
+
+test("internal PUT /persona without token is rejected and store untouched", async () => {
+  // setupInternal("t")：必须带 token 启动，无 token 的写请求才应被拒
+  // （apiToken 为空时 isAuthorized 恒放行——与 /profile 的既有语义一致）。
+  const { store, settings, route } = setupInternal("t");
+  const res = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/persona", "PUT", { persona: { name: "evil" } }), res);
+  assert.equal(res.statusCode, 401);
+  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {} });
+  store.close();
+});
+
+test("internal PUT /persona with token round-trips; corrupt JSON body does not land", async () => {
+  const { store, settings, route } = setupInternal("t");
+  const headers = { authorization: "Bearer t" };
+  const ok = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/persona", "PUT", { persona: { name: "Amarre", enabled: true } }, headers), ok);
+  assert.equal(ok.statusCode, 200);
+  assert.equal(settings.getPersona().default.name, "Amarre");
+  const bad = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/persona", "PUT", "not json", headers), bad);
+  // 路由层对坏 JSON 容错（parseBody 口径：坏体不清空库内值），原样回显现值
+  assert.equal(bad.statusCode, 200);
+  assert.equal(settings.getPersona().default.name, "Amarre");
+  store.close();
+});
+
+test("internal PUT /persona multi-card form replaces fully; legacy form merges default", async () => {
+  const { store, settings, route } = setupInternal("t");
+  const headers = { authorization: "Bearer t" };
+  // 先铺一张 byAgent 卡
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", enabled: true });
+  // 旧形 PUT（单对象）：只动 default、byAgent 保留
+  const legacy = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/persona", "PUT", { persona: { name: "Amarre-改", enabled: true } }, headers), legacy);
+  assert.equal(legacy.statusCode, 200);
+  assert.equal(settings.getPersona().default.name, "Amarre-改");
+  assert.equal(settings.getPersona().byAgent.zephyr.name, "泽菲尔", "legacy PUT keeps byAgent");
+  // 新形 PUT（多卡）：全量替换
+  const multi = new FakeRes();
+  await route.handler(req("/api/dsh-mneme/persona", "PUT", { persona: { default: { name: "默认卡", enabled: true }, byAgent: { zephyr: { name: "泽菲尔-新", enabled: true } } } }, headers), multi);
+  assert.equal(multi.statusCode, 200);
+  const got = settings.getPersona();
+  assert.equal(got.default.name, "默认卡");
+  assert.equal(got.byAgent.zephyr.name, "泽菲尔-新");
+  store.close();
+});
+
+// ---- standalone API（Bearer 数据面，真端口 + fetch） ------------------------
+
+async function setupStandalone() {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const api = createStandaloneApi({ service, store, config: {}, settings, logger: null, port: 0 });
+  await api.ready;
+  const base = `http://127.0.0.1:${api.port}`;
+  const auth = { authorization: `Bearer ${api.token}` };
+  return {
+    store, settings, base, auth,
+    close: () => {
+      api.server.closeIdleConnections?.();
+      api.server.close();
+      store.close();
+    }
+  };
+}
+
+test("standalone GET/PUT /persona behind Bearer gate round-trips", async () => {
+  const t = await setupStandalone();
+  try {
+    const get1 = await fetch(`${t.base}/persona`, { headers: t.auth });
+    assert.equal(get1.status, 200);
+    assert.deepEqual((await get1.json()).persona, { default: {}, byAgent: {} });
+    const put = await fetch(`${t.base}/persona`, {
+      method: "PUT",
+      headers: { ...t.auth, "content-type": "application/json" },
+      body: JSON.stringify({ persona: { name: "Zelphi", enabled: false } })
+    });
+    assert.equal(put.status, 200);
+    assert.equal((await put.json()).persona.default.name, "Zelphi");
+    const bad = await fetch(`${t.base}/persona`, {
+      method: "PUT",
+      headers: { ...t.auth, "content-type": "application/json" },
+      body: "not json"
+    });
+    assert.equal(bad.status, 400);
+    assert.equal(t.settings.getPersona().default.name, "Zelphi");
+  } finally {
+    t.close();
+  }
+});
+
+test("standalone /persona without Bearer is 401", async () => {
+  const t = await setupStandalone();
+  try {
+    const res = await fetch(`${t.base}/persona`, { method: "PUT", body: "{}" });
+    assert.equal(res.status, 401);
+    assert.deepEqual(t.settings.getPersona(), { default: {}, byAgent: {} });
+  } finally {
+    t.close();
+  }
+});

package/test/persona-flag.test.js

@@ -0,0 +1,36 @@
+// personaEnabled flag wiring (#254-style): schema key + whitelist pair must
+// surface in /features effective with default false — a missing key would make
+// the panel toggle silently ineffective (client reads effective to register).
+import test from "node:test";
+import assert from "node:assert/strict";
+import { Config } from "../src/config.js";
+import { createSettings, FEATURE_FLAG_SPEC } from "../src/settings.js";
+import { createStore } from "../src/store.js";
+
+test("config schema has personaEnabled defaulting to false", () => {
+  const cfg = Config({});
+  assert.equal(cfg.personaEnabled, false);
+  // 顶层扁平布尔：显式 true 穿透
+  const cfgOn = Config({ personaEnabled: true });
+  assert.equal(cfgOn.personaEnabled, true);
+});
+
+test("personaEnabled is in the boolean whitelist and spec export", () => {
+  assert.ok(FEATURE_FLAG_SPEC.booleans.includes("personaEnabled"));
+  // 默认关：不在 lightMode 排除名单（轻量纯文本注入物，用户显式勾选赢——
+  // 定性同 actionPipelineEnabled；若未来要进名单，此处会失败并提示改设计稿④）
+  const cfg = Config({});
+  const light = cfg.lightMode === true ? cfg : cfg;
+  void light; // lightMode 定性由 api.test.js 计数锁与 config.js 注释共同钉住
+});
+
+test("effective snapshot includes personaEnabled (false default) via featureSnapshot path", () => {
+  const store = createStore(":memory:");
+  const settings = createSettings(store.db);
+  // settings.setFeatureFlags 逐键校验合并写：白名单键可写（w1 已锁 TypeError 面）
+  settings.setFeatureFlags({ personaEnabled: true });
+  assert.equal(settings.getFeatureFlags().personaEnabled, true);
+  // 清掉覆盖后 effective 应回落到 config 默认 false——由 api.test.js 的
+  // 计数锁 + personaEnabled 默认值断言在 /features 路径上完整验证（w1 已同步 +1）。
+  store.close();
+});

package/test/persona-inject.test.js

@@ -0,0 +1,145 @@
+// Persona injection via renderUserSettings (user-settings context, order 85).
+// Locks: with either gate off, output is byte-identical to the legacy rendering
+// (old users see zero change); with both gates on, persona lines lead the block
+// (design ⑥: persona → profile → rules, rules stay hardest) and go through
+// escapePromptVars.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createService } from "../src/service.js";
+import { createInjector } from "../src/inject.js";
+import { createSettings } from "../src/settings.js";
+
+function setup(over = {}) {
+  const store = createStore(":memory:");
+  const service = createService({ store, mirror: null, config: {} });
+  const settings = createSettings(store.db);
+  const contexts = [];
+  const ctx = {
+    systemPrompt: {
+      context(def) {
+        contexts.push(def);
+        return () => {};
+      }
+    }
+  };
+  const config = { maxInjectedItems: 3, importanceThreshold: 3, ...over };
+  createInjector(ctx, service, settings, config);
+  const settingsCtx = contexts.find((c) => c.name === "user-settings");
+  return { store, settings, settingsCtx };
+}
+
+test("legacy output unchanged when config gate off (persona stored but ignored)", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: false });
+  settings.setProfile("用户是规划背景");
+  settings.setRules(["不提及用户名"]);
+  settings.setPersona({ name: "Amarre", personality: "轻松幽默", enabled: true });
+  const text = settingsCtx.text({});
+  // 逐字节等于历史渲染：无人格行、无人格名
+  assert.equal(text, escapeless([
+    "[用户设置] 来自 dsh-mneme 的用户画像与规则：",
+    "- 用户画像：用户是规划背景",
+    "- 规则：不提及用户名"
+  ].join("\n")));
+  store.close();
+});
+
+test("legacy output unchanged when persona.enabled off (config gate on)", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  settings.setProfile("用户是规划背景");
+  settings.setPersona({ name: "Amarre", personality: "轻松幽默", enabled: false });
+  const text = settingsCtx.text({});
+  assert.ok(text.includes("用户画像"));
+  assert.ok(!text.includes("人格"));
+  store.close();
+});
+
+test("empty block stays empty when only persona exists but a gate is off", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: false });
+  settings.setPersona({ name: "Amarre", enabled: true });
+  assert.equal(settingsCtx.text({}), "");
+  store.close();
+});
+
+test("both gates on: persona lines lead, then profile, then rules", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  settings.setProfile("用户是规划背景");
+  settings.setRules(["不提及用户名"]);
+  settings.setPersona({ name: "Amarre", personality: "轻松幽默", replyStyle: "先给结论再解释", enabled: true });
+  const text = settingsCtx.text({});
+  const idxPersona = text.indexOf("你的人格名字：Amarre");
+  const idxProfile = text.indexOf("用户画像：用户是规划背景");
+  const idxRule = text.indexOf("规则：不提及用户名");
+  assert.ok(idxPersona > -1, "persona line present");
+  assert.ok(idxProfile > idxPersona, "profile after persona (design ⑥)");
+  assert.ok(idxRule > idxProfile, "rules after profile (rules hardest)");
+  assert.ok(text.includes("人格性格设定：轻松幽默"));
+  assert.ok(text.includes("回复要求：先给结论再解释"));
+  store.close();
+});
+
+test("persona with blank text fields renders no persona lines (no empty bullets)", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "  ", personality: "", enabled: true });
+  assert.equal(settingsCtx.text({}), "");
+  settings.setProfile("有画像");
+  const text = settingsCtx.text({});
+  assert.ok(!text.includes("人格"));
+  store.close();
+});
+
+test("persona text goes through escapePromptVars (no raw braces)", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "{{evil}}", enabled: true });
+  const text = settingsCtx.text({});
+  assert.ok(!text.includes("{{"), "no raw {{ in user-settings block");
+  assert.ok(!text.includes("}}"), "no raw }} in user-settings block");
+  store.close();
+});
+
+// ---- v1.2 多卡寻址：按会话身份取卡，取不到落 default ------------------------
+
+test("session identity hit: byAgent card wins over default", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "Amarre", enabled: true }); // default
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", personality: "冷危占有", enabled: true });
+  const ctxWithId = { agent: { session: { header: { agentPreset: "zephyr" } } } };
+  const text = settingsCtx.text(ctxWithId);
+  assert.ok(text.includes("你的人格名字：泽菲尔"), "byAgent card injected");
+  assert.ok(!text.includes("Amarre"), "default card not injected when identity hit");
+  store.close();
+});
+
+test("session identity miss: falls back to default card", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "Amarre", enabled: true });
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", enabled: true });
+  const ctxUnknown = { agent: { session: { header: { agentPreset: "unknown-bot" } } } };
+  const text = settingsCtx.text(ctxUnknown);
+  assert.ok(text.includes("Amarre"), "default on identity miss");
+  assert.ok(!text.includes("泽菲尔"), "other card not leaked");
+  store.close();
+});
+
+test("identity card disabled (enabled=false) falls back to default, not partial card", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "Amarre", enabled: true });
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", personality: "冷", enabled: false });
+  const ctxWithId = { agent: { session: { header: { agentPreset: "zephyr" } } } };
+  const text = settingsCtx.text(ctxWithId);
+  assert.ok(text.includes("Amarre"), "disabled id card → default");
+  assert.ok(!text.includes("泽菲尔"), "disabled card never partially injected");
+  store.close();
+});
+
+test("session without header (mock/old host) behaves exactly like v1 (default)", () => {
+  const { store, settings, settingsCtx } = setup({ personaEnabled: true });
+  settings.setPersona({ name: "Amarre", personality: "轻松幽默", enabled: true });
+  const text = settingsCtx.text({}); // 无 session.header → default，与 v1 一致
+  assert.ok(text.includes("你的人格名字：Amarre"));
+  assert.ok(text.includes("人格性格设定：轻松幽默"));
+  store.close();
+});
+
+// 期望值工具：直接写明文（本组用例不含需转义字符，escapePromptVars 为恒等）。
+function escapeless(s) { return s; }

package/test/persona-settings.test.js

@@ -0,0 +1,145 @@
+// Persona settings (user_settings "persona" key) — v1.2 多卡模型。
+// Locks: legacy v1 single-object reads as default; byAgent cards round-trip;
+// corruption returns empty store without throwing; unknown fields dropped.
+// Whitelist lock guards the #254-style pit: a flag missing from
+// FEATURE_FLAG_BOOLEANS would make the panel toggle silently ineffective.
+import test from "node:test";
+import assert from "node:assert/strict";
+import { createStore } from "../src/store.js";
+import { createSettings } from "../src/settings.js";
+
+function setup() {
+  const store = createStore(":memory:");
+  const settings = createSettings(store.db);
+  return { store, settings };
+}
+
+test("persona defaults to empty store; default card round-trips via single-object form", () => {
+  const { store, settings } = setup();
+  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {} });
+  const input = {
+    name: "Amarre",
+    personality: "轻松幽默，讲解用类比",
+    replyStyle: "先给结论再解释",
+    enabled: false,
+    provenance: { sourceMemoryIds: [], generatedAt: "", reviewedByUser: false }
+  };
+  settings.setPersona(input);
+  const got = settings.getPersona();
+  assert.deepEqual(got.default, input);
+  assert.deepEqual(got.byAgent, {});
+  store.close();
+});
+
+test("default card write drops unknown fields", () => {
+  const { store, settings } = setup();
+  settings.setPersona({ name: "Amarre", sneaky: "field" });
+  const got = settings.getPersona();
+  assert.equal(got.default.name, "Amarre");
+  assert.equal("sneaky" in got.default, false);
+  store.close();
+});
+
+test("persona read of corrupt JSON returns empty store without throwing", () => {
+  const { store, settings } = setup();
+  settings.setPersona({ name: "seed" });
+  // 直改底层键模拟损坏（面板口径：坏值显示为空、可重写，不抛错）
+  store.db.prepare("UPDATE user_settings SET value = ? WHERE key = 'persona'").run("not json at all");
+  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {} });
+  store.close();
+});
+
+test("persona read of non-object JSON (array/number) returns empty store", () => {
+  const { store, settings } = setup();
+  store.db.prepare("INSERT INTO user_settings (key, value) VALUES ('persona', '[1,2]')").run();
+  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {} });
+  store.db.prepare("UPDATE user_settings SET value = '42' WHERE key = 'persona'").run();
+  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {} });
+  store.close();
+});
+
+test("setPersona tolerates non-object input (writes empty persona)", () => {
+  const { store, settings } = setup();
+  settings.setPersona(null);
+  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {} });
+  settings.setPersona("nope");
+  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {} });
+  store.close();
+});
+
+// ---- v1.2 多卡模型：{ default, byAgent }，旧单对象读作 default 兼容 ----------
+
+test("v1 legacy single-object persona reads as default (zero migration)", () => {
+  const { store, settings } = setup();
+  // 直写 v1 形（单对象）模拟存量库
+  store.db.prepare("INSERT INTO user_settings (key, value) VALUES ('persona', ?)")
+    .run(JSON.stringify({ name: "Amarre", personality: "轻松幽默", enabled: true }));
+  const got = settings.getPersona();
+  assert.equal(got.default.name, "Amarre");
+  assert.equal(got.default.enabled, true);
+  assert.deepEqual(got.byAgent, {});
+  store.close();
+});
+
+test("byAgent card round-trips via setPersonaFor/getPersonaFor", () => {
+  const { store, settings } = setup();
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", personality: "冷危占有", enabled: true });
+  assert.deepEqual(settings.getPersonaFor("zephyr"), { name: "泽菲尔", personality: "冷危占有", enabled: true });
+  // default 仍在且未被影响
+  assert.deepEqual(settings.getPersona().default, {});
+  // 卡列表含 zephyr
+  assert.deepEqual(settings.listPersonas(), ["zephyr"]);
+  store.close();
+});
+
+test("getPersonaFor falls back to default when id card missing or disabled", () => {
+  const { store, settings } = setup();
+  settings.setPersona({ name: "Amarre", enabled: true }); // 单对象形写 default
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", enabled: false }); // 卡存在但关
+  // 未注册身份 → default
+  assert.equal(settings.getPersonaFor("unknown-bot").name, "Amarre");
+  // 身份卡存在但 enabled=false → 落 default（兜底优先，不注入半张卡）
+  assert.equal(settings.getPersonaFor("zephyr").name, "Amarre");
+  // 身份缺失（null/空串）→ default
+  assert.equal(settings.getPersonaFor(null).name, "Amarre");
+  assert.equal(settings.getPersonaFor("").name, "Amarre");
+  store.close();
+});
+
+test("setPersona single-object form merges default and keeps byAgent", () => {
+  const { store, settings } = setup();
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", enabled: true });
+  settings.setPersona({ name: "Amarre-新", enabled: true }); // 单对象形
+  const got = settings.getPersona();
+  assert.equal(got.default.name, "Amarre-新");
+  assert.equal(got.byAgent.zephyr.name, "泽菲尔", "byAgent must survive a legacy-form write");
+  store.close();
+});
+
+test("removePersona deletes byAgent card but default is protected", () => {
+  const { store, settings } = setup();
+  settings.setPersonaFor("zephyr", { name: "泽菲尔", enabled: true });
+  assert.equal(settings.removePersona("zephyr"), true);
+  assert.deepEqual(settings.listPersonas(), []);
+  assert.equal(settings.removePersona("default"), false, "default card cannot be removed");
+  assert.equal(settings.removePersona("ghost"), false);
+  store.close();
+});
+
+test("corrupt multi-card JSON reads as empty store without throwing", () => {
+  const { store, settings } = setup();
+  settings.setPersona({ name: "seed" });
+  store.db.prepare("UPDATE user_settings SET value = ? WHERE key = 'persona'").run("broken {");
+  assert.deepEqual(settings.getPersona(), { default: {}, byAgent: {} });
+  store.close();
+});
+
+test("personaEnabled is in the feature-flag boolean whitelist", () => {
+  const { store, settings } = setup();
+  // 写侧逐键校验的合并写：未知键抛 TypeError，白名单键可用——
+  // 这条锁防「白名单漏登记 → 面板开关静默失效」（#254 同型坑）。
+  settings.setFeatureFlags({ personaEnabled: true });
+  assert.equal(settings.getFeatureFlags().personaEnabled, true);
+  assert.throws(() => settings.setFeatureFlags({ notARealFlag: true }), TypeError);
+  store.close();
+});

package/test/pipeline-activities.test.js

@@ -0,0 +1,155 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { businessCommandOf, activityKey, tallyActivities } from "../src/pipeline-activities.js";
+
+// 这组测试守两件事：
+//   ① 分组结果落在「人能扫」的量级（业务命令才进清单，shell 语法不进）
+//   ② 🔴 隐私硬规则：位置参数一律丢弃——回执要显示在界面上，而完整命令行里
+//      几乎必然含绝对路径（路径里含本机用户名）。这一条比功能本身重要。
+
+test("业务命令：抽出 {动词, 子命令, 旗标}", () => {
+  assert.deepEqual(businessCommandOf("git status"), { verb: "git", sub: "status", flags: [] });
+  assert.deepEqual(businessCommandOf("git push origin main"), { verb: "git", sub: "push", flags: [] });
+  assert.deepEqual(businessCommandOf("gh pr merge --rebase"), { verb: "gh", sub: "pr", flags: ["--rebase"] });
+  assert.deepEqual(businessCommandOf("npm test"), { verb: "npm", sub: "test", flags: [] });
+  // 子命令可空
+  assert.deepEqual(businessCommandOf("npm"), { verb: "npm", sub: "", flags: [] });
+});
+
+test("🔴 隐私硬规则：位置参数一律丢弃，只留动词/子命令/旗标", () => {
+  // 实测里真实出现过这种形状：路径含本机用户名。回执绝不能把它带出去。
+  const r = businessCommandOf('set-location "c:\\users\\somebody\\desktop\\proj"; git commit -m "x"');
+  // 整段里第一个可识别的是 set-location（不在名单）→ 由分段器处理；这里直接测 git commit
+  assert.equal(businessCommandOf("git commit -m \"修好了\"").verb, "git");
+  assert.deepEqual(businessCommandOf("git commit -m \"修好了\"").flags, ["-m"]);
+  // 位置参数（文件名、分支名、路径）一个都不该出现在结果里
+  const withPath = businessCommandOf("git add src/foo.js C:/Users/name/x.md");
+  assert.equal(JSON.stringify(withPath).includes("Users"), false, "路径绝不能出现在结果里");
+  assert.equal(JSON.stringify(withPath).includes("foo.js"), false, "文件名是位置参数，该丢");
+});
+
+test("🔴 旗标里的路径参数也要挡住（--file=C:/x 这种）", () => {
+  const r = businessCommandOf("git commit --file=C:/Users/name/msg.txt -m x");
+  assert.equal(JSON.stringify(r).includes("Users"), false, "带路径的旗标不许原样带出");
+  // 纯旗标照常留
+  assert.deepEqual(businessCommandOf("gh pr list --state all").flags.includes("--state"), true);
+});
+
+test("非业务命令一律不产清单项（shell 语法不是活动）", () => {
+  // 实测里密度最高的就是这些——它们不是"做了什么"，是句子成分
+  for (const noise of [
+    'write-output "=== 检查 ==="',
+    "select-object -first 10",
+    "foreach-object { $_ }",
+    "echo hello",
+    "}",
+    "if (test-path x) { }",
+    "$erroractionpreference='continue'",
+    "cd C:/some/dir"
+  ]) {
+    assert.equal(businessCommandOf(noise), null, `${noise} 不该进清单`);
+  }
+});
+
+test("分段：一条命令里的多个业务动作分别计入", () => {
+  const r = tallyActivities([{ command: 'cd C:/x; git status; echo "---"; npm test' }]);
+  const keys = r.activities.map((a) => a.key).sort();
+  assert.deepEqual(keys, ["git status", "npm test"], "cd 与 echo 应被排除");
+  assert.equal(r.shellNoise, 2, "shell 噪音要单独计数，不能与业务动作混为一谈");
+  assert.equal(r.totalSegments, 4);
+});
+
+test("计数与排序：按出现次数降序，同次数按名字", () => {
+  const r = tallyActivities([
+    { command: "git status" },
+    { command: "npm test; git status" },
+    { command: "git status && gh pr list" }
+  ]);
+  assert.equal(r.activities[0].key, "git status");
+  assert.equal(r.activities[0].count, 3);
+  assert.equal(r.businessSegments, 5);
+});
+
+test("旗标并集：同一动作的不同旗标合并展示，且截断", () => {
+  const r = tallyActivities([
+    { command: "gh pr merge --rebase" },
+    { command: "gh pr merge --squash" }
+  ]);
+  assert.equal(r.activities.length, 1);
+  assert.equal(r.activities[0].count, 2);
+  assert.deepEqual(r.activities[0].flags.sort(), ["--rebase", "--squash"]);
+});
+
+test("🔴 回归：脚本路径不得被当成子命令（端到端实测抓到的真 bug）", () => {
+  // 实测里出现过 `node d:\dsh\.dsh\_tmp-mo-probe.mjs` —— 原实现把整条路径当 sub，
+  // 于是回执里带出本机路径（可能含用户名）。这正是隐私红线要挡的东西。
+  const r = businessCommandOf('node d:\\dsh\\.dsh\\_tmp-probe.mjs');
+  assert.equal(r.verb, "node");
+  assert.equal(JSON.stringify(r).includes("dsh"), false, "路径绝不能出现在结果里");
+  assert.equal(r.sub, "", "路径不是子命令，宁可留空");
+  // 相对路径同理
+  const r2 = businessCommandOf("node test/pipeline-nudge.test.js --test");
+  assert.equal(r2.sub, "", "文件名不是子命令");
+  assert.deepEqual(r2.flags, ["--test"]);
+});
+
+test("🔴 回归：`git -C <path> log` 要扫到 log，而不是把 `-C` 的值当子命令", () => {
+  // 实测出现过 `git (join-path -C --oneline --porcelain` 这种读不懂的清单行。
+  const r = businessCommandOf('git -C C:/some/dir log --oneline -3');
+  assert.equal(r.verb, "git");
+  assert.equal(r.sub, "log", "子命令在 -C 的值之后，必须扫描而不是取第一个");
+  assert.equal(JSON.stringify(r).includes("some"), false, "路径不许带出");
+});
+
+test("子命令形状窄：含 $、括号、引号、长串的一律不算", () => {
+  for (const bad of ["$p", "$(Get-Item", "C:/x/y", "d:\\a", "averyveryverylongsubcommandname", "'\"", "{", "@{"]) {
+    const r = businessCommandOf(`git ${bad} status`);
+    // 要么扫不到（sub 空），要么扫到 status；无论如何不能是那个坏值
+    assert.equal(r.sub === bad.toLowerCase(), false, `${bad} 不该被当成子命令`);
+  }
+});
+
+test("旗标里带 = 或路径的一律丢（--file=C:/x 这种）", () => {
+  const r = businessCommandOf("git commit --file=C:/Users/name/msg.txt -m x");
+  assert.equal(JSON.stringify(r).includes("Users"), false);
+  assert.deepEqual(r.flags, ["-m"], "带值/路径的旗标整个丢掉");
+});
+
+test("重定向与引号不影响识别", () => {
+  assert.deepEqual(businessCommandOf('npm test 2>&1 | Select-String "x"'), { verb: "npm", sub: "test", flags: [] });
+  assert.equal(businessCommandOf("'git' 'status'").verb, "git");
+});
+
+test("坏输入不抛：空、非串、缺字段一律安全返回", () => {
+  for (const bad of [null, undefined, "", "   ", 0, {}]) {
+    assert.equal(businessCommandOf(bad), null);
+  }
+  for (const bad of [null, undefined, [], [{}], [{ command: null }], [0, "x"]]) {
+    const r = tallyActivities(bad);
+    assert.deepEqual(r.activities, []);
+    assert.equal(typeof r.shellNoise, "number");
+  }
+  assert.equal(activityKey(null), "");
+});
+
+test("产出可读：key 是 `动词 子命令`，trim 过", () => {
+  assert.equal(activityKey({ verb: "git", sub: "status" }), "git status");
+  assert.equal(activityKey({ verb: "npm", sub: "" }), "npm");
+});
+
+test("没有子命令时用第一个旗标当键：node --test 与 node --check 不能并成一行", () => {
+  // 端到端实测里 16 次 node 调用被并成一条 —— 但它们语义不同（跑测试 vs 查语法）。
+  const r = tallyActivities([
+    { command: "node --test x.test.js" },
+    { command: "node --test y.test.js" },
+    { command: "node --check src/foo.js" }
+  ]);
+  const keys = r.activities.map((a) => a.key).sort();
+  assert.deepEqual(keys, ["node --check", "node --test"], "旗标区分语义，该分开");
+  assert.equal(r.activities.find((a) => a.key === "node --test").count, 2);
+});
+
+test("旗标只当补充：有子命令时键仍以子命令为准", () => {
+  const k = activityKey({ verb: "git", sub: "status", flags: ["-C", "--porcelain"] });
+  assert.equal(k, "git status", "-C 后面本来跟着被丢弃的路径，不该挤进键里");
+});