open-memex 0.7.0-alpha.1 → 0.7.0-alpha.13

package/scripts/smoke-mcp.ts

@@ -120,7 +120,53 @@ try {
   check("memory_search output masked", !searchText.includes("sk-test-FAKESECRET1234567890abcdef"));
 
   const list = await req("tools/call", { name: "memory_list", arguments: {} });
-  check("memory_list works", (list.result?.content?.[0]?.text ?? "").includes(savedId));
+  const listText = list.result?.content?.[0]?.text ?? "";
+  check("memory_list works", listText.includes(savedId));
+  // D68: the list is the user's inventory — numbered, plain language,
+  // with provenance and age, not the raw developer format.
+  check("memory_list is numbered structured lines (D68)", /^\d+\. \[fact\] id=/m.test(listText), listText.slice(0, 120));
+  check("memory_list keeps raw provenance field (D68)", listText.includes("source=tool"), listText.slice(0, 160));
+  check("memory_list shows age token (D68)", /created=(now|\d+[mhd])/.test(listText), listText.slice(0, 160));
+  const listBoth = await req("tools/call", { name: "memory_list", arguments: { scope: "both" } });
+  const listBothText = listBoth.result?.content?.[0]?.text ?? "";
+  check("memory_list both scopes (D68)", listBothText.includes("About you"));
+  // D70: numbers run across the whole listing, so "delete #3" names one memory.
+  // Needs a personal entry too, or there is only one section to number.
+  const personalAdd = await req("tools/call", {
+    name: "memory_add",
+    arguments: { content: "mcp e2e probe: a personal note for the both-scopes listing", type: "fact", scope: "personal" },
+  });
+  check("personal memory added for the both-scopes probe", (personalAdd.result?.content?.[0]?.text ?? "").includes("id="), (personalAdd.result?.content?.[0]?.text ?? "").slice(0, 120));
+  const listBoth2 = await req("tools/call", { name: "memory_list", arguments: { scope: "both" } });
+  const listBothText2 = listBoth2.result?.content?.[0]?.text ?? "";
+  const bothNums = [...listBothText2.matchAll(/^(\d+)\. \[/gm)].map((m) => Number(m[1]));
+  check(
+    "memory_list numbers are unique across scopes (D70)",
+    bothNums.length > 1 && new Set(bothNums).size === bothNums.length && bothNums[0] === 1,
+    JSON.stringify(bothNums),
+  );
+
+  // D68: truncation is disclosed, never silent — one shown, total stated.
+  const add2 = await req("tools/call", {
+    name: "memory_add",
+    arguments: { content: "mcp e2e probe: second memory for truncation", type: "fact" },
+  });
+  const savedId2 = ((add2.result?.content?.[0]?.text ?? "").match(/id=([A-Za-z0-9_]+)/) ?? [])[1];
+  const listLim = await req("tools/call", { name: "memory_list", arguments: { limit: 1 } });
+  const listLimText = listLim.result?.content?.[0]?.text ?? "";
+  check("memory_list discloses truncation (D68)", /and \d+ more not shown/.test(listLimText), listLimText.slice(0, 200));
+
+  // D68: soft forget hides (retracted) — gone from the active list,
+  // visible in the audit view, hard forget still removes it everywhere.
+  const soft = await req("tools/call", { name: "memory_forget", arguments: { id: savedId2, soft: true } });
+  check("memory_forget soft works (D68)", (soft.result?.content?.[0]?.text ?? "").includes("Hidden"), (soft.result?.content?.[0]?.text ?? "").slice(0, 120));
+  const listAfterSoft = await req("tools/call", { name: "memory_list", arguments: {} });
+  check("hidden memory out of active list (D68)", !(listAfterSoft.result?.content?.[0]?.text ?? "").includes(savedId2));
+  const listAll = await req("tools/call", { name: "memory_list", arguments: { include: "all" } });
+  const listAllText = listAll.result?.content?.[0]?.text ?? "";
+  check("hidden memory visible in audit view (D68)", listAllText.includes(savedId2) && listAllText.includes("[retracted]"), listAllText.slice(0, 200));
+  const forget2 = await req("tools/call", { name: "memory_forget", arguments: { id: savedId2 } });
+  check("memory_forget still deletes a hidden memory (D68)", (forget2.result?.content?.[0]?.text ?? "").toLowerCase().includes("deleted"));
 
   const forget = await req("tools/call", { name: "memory_forget", arguments: { id: savedId } });
   check("memory_forget works", (forget.result?.content?.[0]?.text ?? "").includes("Deleted"));

package/scripts/smoke-pure.ts

@@ -1,15 +1,53 @@
 // Quick smoke test — runs the pure-logic modules (no bun:sqlite dependency).
 // Usage:  node --experimental-strip-types scripts\smoke-pure.ts
-import { parse, serialize, ulid, normalizeFrontmatter, msToRfc3339, timeToMs, parseRawFrontmatter, type Frontmatter } from "../src/store/markdown.ts";
+import { parse, serialize, ulid, normalizeFrontmatter, msToRfc3339, timeToMs, parseRawFrontmatter, normalizeAliases, type Frontmatter } from "../src/store/markdown.ts";
 import { planConversion, isV2File, migrateV2 } from "../src/store/v2migrate.ts";
 import { redact, findSecret } from "../src/redact.ts";
-import { detectKeywords } from "../src/capture/keywords.ts";
+import { detectKeywords, scanKeywords } from "../src/capture/keywords.ts";
 import { DEFAULT_CONFIG } from "../src/config.ts";
-import { resolveProjectScope, resolveCwdScope, PERSONAL_SCOPE } from "../src/scope.ts";
+import { resolveProjectScope, resolveCwdScope, pickScopeRoot, PERSONAL_SCOPE } from "../src/scope.ts";
 import { cjkIndexText, cjkQueryExpr, hasCjk } from "../src/retrieve/cjk.ts";
 import { toFtsQuery } from "../src/retrieve/query.ts";
 import { contentHash, similarity, NEAR_DUP_THRESHOLD } from "../src/store/lifecycle.ts";
 import { userMcpConfigPath, mergeServerEntry, detectInstalledClients, mergePluginEntry, mergeV2PluginEntry, removeV2PluginEntry, opencodeGlobalConfigPath, printManualEntryHint, parseJsonConfig, removeServerEntry, removePluginEntry, removeInstructionsSection, LEGACY_PACKAGE_NAME, shouldInstallSkill } from "../src/init.ts";
+import { z } from "zod";
+import { memoryAddArgs } from "../src/tools/ops.ts";
+import { dataRootPath, homeOverride } from "../src/paths.ts";
+import { configFilePath, loadConfig, stripJsonComments } from "../src/config.ts";
+
+console.log("== jsonc parsing + config invariants (P0) ==");
+{
+  // The pre-fix regex stripper ate "src/**/secrets" as a block comment,
+  // silently disabling the user's redact rule.
+  const doc = JSON.parse(stripJsonComments(`{
+    // a line comment with a "quote
+    "redactPatterns": ["src/**/secrets", "a /* not a comment */ b"],
+    /* a real block comment */
+    "memoryDir": ".ai/open-memex",
+  }`)) as { redactPatterns: string[] };
+  ok("redact pattern with ** survives comment stripping",
+    doc.redactPatterns[0] === "src/**/secrets" && doc.redactPatterns[1] === "a /* not a comment */ b",
+    JSON.stringify(doc.redactPatterns));
+}
+{
+  // loadConfig must enforce the memoryDir invariant on hand-edited files.
+  const saved = process.env.OPEN_MEMEX_CONFIG;
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "om-cfg-"));
+  const file = path.join(dir, "c.jsonc");
+  fs.writeFileSync(file, JSON.stringify({ memoryDir: "../../shared" }));
+  const errs: unknown[] = [];
+  const origErr = console.error;
+  console.error = (...a: unknown[]) => errs.push(a);
+  try {
+    process.env.OPEN_MEMEX_CONFIG = file;
+    ok("escaping memoryDir falls back to default", loadConfig().memoryDir === ".ai/open-memex");
+  } finally {
+    console.error = origErr;
+    if (saved === undefined) delete process.env.OPEN_MEMEX_CONFIG;
+    else process.env.OPEN_MEMEX_CONFIG = saved;
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
 
 let fails = 0;
 function ok(name: string, cond: boolean, info?: unknown) {
@@ -57,6 +95,28 @@ ok("id survives", parsed?.fm.id === a);
 ok("tags survive", JSON.stringify(parsed?.fm.tags) === '["hello","world"]');
 ok("body survives", parsed?.body.trim() === body);
 
+console.log("== capture aliases (D61) ==");
+ok("normalize trims/dedupes/caps at 4",
+  JSON.stringify(normalizeAliases(["  Time Off ", "time off", "", "节假日", "vacation", "PTO", "leave"])) === '["Time Off","节假日","vacation","PTO"]');
+ok("normalize of undefined is empty", JSON.stringify(normalizeAliases(undefined)) === "[]");
+const fmA: Frontmatter = { ...fm, id: ulid(), aliases: ["time off", "节假日", "vacation days"] };
+const parsedA = parse(serialize(fmA, "body text"));
+ok("aliases survive round-trip",
+  JSON.stringify(parsedA?.fm.aliases) === '["time off","节假日","vacation days"]');
+ok("no aliases -> field omitted from file",
+  !/^aliases:/m.test(serialize(fm, "x")));
+ok("empty aliases array -> field omitted",
+  !/^aliases:/m.test(serialize({ ...fm, aliases: [] }, "x")));
+ok("parse caps hand-edited aliases at 4",
+  (normalizeFrontmatter({ id: "x", aliases: ["1", "2", "3", "4", "5"] } as never).aliases ?? []).length === 4);
+{
+  // D61 review: the tool schema must never reject a sloppy alias list —
+  // normalization decides, not validation (bad aliases are noise).
+  const shape = z.object(memoryAddArgs);
+  const sloppy = shape.safeParse({ content: "x", aliases: ["a", "", "b", "c", "d", "e"] });
+  ok("tool schema accepts >4 / blank aliases (normalize drops them)", sloppy.success);
+}
+
 console.log("== redact ==");
 const r1 = redact("api key is <private>sk-supersecretkey</private> ok", DEFAULT_CONFIG.redactPatterns);
 ok("private stripped", !r1.content.includes("sk-supersecretkey"));
@@ -199,6 +259,105 @@ ok("no false positive", hits3.length === 0);
 const hits4 = detectKeywords("Please note that FTS5 needs prefix matches", DEFAULT_CONFIG);
 ok("please-note matched", hits4.length === 1);
 
+console.log("== keywords: capture gaps (D65) ==");
+// "帮我记…" is the most natural Chinese phrasing and used to match nothing.
+// Routes personal, mirroring 替我记 (the 我-rule), unlike 帮我们记 (project).
+const g1 = detectKeywords("帮我记住：这个项目用 pnpm", DEFAULT_CONFIG);
+ok("帮我记住 matched", g1.length === 1, JSON.stringify(g1));
+ok("帮我记住 → personal", g1[0]?.personal === true);
+ok("帮我记住 body clean", g1[0]?.content === "这个项目用 pnpm", g1[0]?.content);
+// A leading 请 defeated every 记住-led pattern ("请记住我…", "请记住：…").
+const g2 = detectKeywords("请记住我不喜欢周五发布", DEFAULT_CONFIG);
+ok("请记住我 matched personal", g2.length === 1 && g2[0]?.personal === true, JSON.stringify(g2));
+const g3 = detectKeywords("请记住：周五不发布", DEFAULT_CONFIG);
+ok("请记住 matched project", g3.length === 1 && g3[0]?.personal === false, JSON.stringify(g3));
+// English: "remember to …" captured a stray leading "to" in the body.
+const g4 = detectKeywords("Remember to run the tests before merging", DEFAULT_CONFIG);
+ok("remember-to body has no stray 'to'", g4.length === 1 && g4[0]?.content === "run the tests before merging", g4[0]?.content);
+// …but the optional "to" must not eat a word that merely starts with it.
+const g5 = detectKeywords("remember Toronto is where the office is", DEFAULT_CONFIG);
+ok("remember Toronto… body intact", g5.length === 1 && g5[0]?.content === "Toronto is where the office is", g5[0]?.content);
+// 帮我们记 still routes project (the 们-rule survives the new 帮我记 pattern).
+const g6 = detectKeywords("帮我们记住：周五不发布", DEFAULT_CONFIG);
+ok("帮我们记住 → project", g6.length === 1 && g6[0]?.personal === false, JSON.stringify(g6));
+
+console.log("== keywords: review follow-ups (D66) ==");
+// The new 帮我记 pattern initially shipped without the (?:请)? its siblings
+// got in D65 — 请帮我记住 fell through again.
+const f1 = detectKeywords("请帮我记住：这个项目用 pnpm", DEFAULT_CONFIG);
+ok("请帮我记住 → personal", f1.length === 1 && f1[0]?.personal === true && f1[0]?.content === "这个项目用 pnpm", JSON.stringify(f1));
+// 帮我记录一下 used to capture mid-word garbage ("录一下：…"). The verb
+// phrase now includes 记录/记录一下 and must end at a separator boundary.
+const f2 = detectKeywords("帮我记录一下：周五不发布", DEFAULT_CONFIG);
+ok("帮我记录一下 body clean", f2.length === 1 && f2[0]?.content === "周五不发布", JSON.stringify(f2));
+const f3 = detectKeywords("替我记录一下：护照在抽屉里", DEFAULT_CONFIG);
+ok("替我记录一下 body clean", f3.length === 1 && f3[0]?.content === "护照在抽屉里", JSON.stringify(f3));
+// The boundary guard: 帮我记得… is not a capture form and must not fire.
+const f4 = detectKeywords("帮我记得带伞", DEFAULT_CONFIG);
+ok("帮我记得 → no capture", f4.length === 0, JSON.stringify(f4));
+// English personal phrasing on par with "remember for me".
+const f5 = detectKeywords("Help me remember: the wifi is on the fridge note", DEFAULT_CONFIG);
+ok("help me remember → personal", f5.length === 1 && f5[0]?.personal === true, JSON.stringify(f5));
+
+console.log("== keywords: separator-less verb phrases (D67) ==");
+// D66's boundary guard was one notch too strict: it demanded a separator even
+// after a COMPLETE verb phrase, so the most natural form - "帮我记一下这个配置",
+// with the noun straight after 记一下 - stopped matching. The boundary now
+// guards the bare verb only (记 must be followed by 住/录/一下 or a separator),
+// so 记得/记着 still cannot produce mid-word garbage.
+const v1 = detectKeywords("帮我记一下这个配置", DEFAULT_CONFIG);
+ok("帮我记一下这个配置 (no separator)", v1.length === 1 && v1[0]?.personal === true && v1[0]?.content === "这个配置", JSON.stringify(g1));
+const v2 = detectKeywords("帮我记住这个配置", DEFAULT_CONFIG);
+ok("帮我记住这个配置 (no separator)", v2.length === 1 && v2[0]?.content === "这个配置", JSON.stringify(g2));
+const v3 = detectKeywords("替我记一下我住在杭州", DEFAULT_CONFIG);
+ok("替我记一下我住在杭州 (no separator)", v3.length === 1 && v3[0]?.personal === true && v3[0]?.content === "我住在杭州", JSON.stringify(g3));
+const v4 = detectKeywords("帮我们记一下这个约定", DEFAULT_CONFIG);
+ok("帮我们记一下这个约定 → project", v4.length === 1 && v4[0]?.personal === false && v4[0]?.content === "这个约定", JSON.stringify(g4));
+const v5 = detectKeywords("替我记着这个流程", DEFAULT_CONFIG);
+ok("替我记着… → no capture (verb continuation)", v5.length === 0, JSON.stringify(v5));
+const v6 = detectKeywords("帮我们记得每周同步", DEFAULT_CONFIG);
+ok("帮我们记得… → no capture (verb continuation)", v6.length === 0, JSON.stringify(v6));
+const v7 = detectKeywords("帮我记：这个项目用 pnpm", DEFAULT_CONFIG);
+ok("帮我记：… (bare verb + separator)", v7.length === 1 && v7[0]?.content === "这个项目用 pnpm", JSON.stringify(v7));
+
+console.log("== keywords: narration is not a trigger (D67) ==");
+// 记得… / remind me… stay out on purpose (D67): they are imperatives aimed at
+// the agent, and a false trigger writes memory nobody reviewed. The two forms
+// already in the list follow the same rule - an explicit separator (or "that")
+// marks a statement to the store.
+const n1 = detectKeywords("别忘了带伞", DEFAULT_CONFIG);
+ok("别忘了带伞 (narration) → no capture", n1.length === 0, JSON.stringify(n1));
+const n2 = detectKeywords("别忘了：周五不发布", DEFAULT_CONFIG);
+ok("别忘了：… (instruction) → project", n2.length === 1 && n2[0]?.personal === false && n2[0]?.content === "周五不发布", JSON.stringify(n2));
+const n3 = detectKeywords("别忘了,每次发布前更新 changelog", DEFAULT_CONFIG);
+ok("别忘了,… (ascii comma) → project", n3.length === 1 && n3[0]?.content === "每次发布前更新 changelog", JSON.stringify(n3));
+const n4 = detectKeywords("Don't forget the wifi password", DEFAULT_CONFIG);
+ok("don't forget <bare> (narration) → no capture", n4.length === 0, JSON.stringify(n4));
+const n5 = detectKeywords("Don't forget that the wifi password is on the fridge", DEFAULT_CONFIG);
+ok("don't forget that … → project", n5.length === 1 && n5[0]?.content === "the wifi password is on the fridge", JSON.stringify(n5));
+const n6 = detectKeywords("don't forget: the wifi password", DEFAULT_CONFIG);
+ok("don't forget: … → project", n6.length === 1 && n6[0]?.content === "the wifi password", JSON.stringify(n6));
+// The 'note' family is unaffected - it was never the ambiguous form.
+const n7 = detectKeywords("note the API is v2", DEFAULT_CONFIG);
+ok("note <bare> still captures", n7.length === 1 && n7[0]?.content === "the API is v2", JSON.stringify(n7));
+const n8 = detectKeywords("记得每次都要跑迁移脚本", DEFAULT_CONFIG);
+ok("记得… → no capture", n8.length === 0, JSON.stringify(n8));
+const n9 = detectKeywords("remind me to lock the door", DEFAULT_CONFIG);
+ok("remind me to… → no capture", n9.length === 0, JSON.stringify(n9));
+
+console.log("== keywords: the length floor reports instead of swallowing (D67) ==");
+// D67 keeps the >=3-char floor (a trigger that yields 这个 is a match on the
+// trigger, not a memory) but a rejection is no longer silent.
+const d1 = scanKeywords("记住：这个", DEFAULT_CONFIG);
+ok("短 body 不捕获", d1.hits.length === 0, JSON.stringify(d1));
+ok("短 body 有说明 (too-short)", d1.dropped.length === 1 && d1.dropped[0]?.reason === "too-short" && d1.dropped[0]?.content === "这个", JSON.stringify(d1.dropped));
+const d2 = scanKeywords("记住：这个配置", DEFAULT_CONFIG);
+ok(">=3 字的照常捕获", d2.hits.length === 1 && d2.dropped.length === 0, JSON.stringify(d2));
+// A rejected personal match must not leak into the project scope: "记住我：OK"
+// must not be re-captured by the generic 记住 as "我：OK".
+const d3 = scanKeywords("记住我：OK", DEFAULT_CONFIG);
+ok("短 personal 不落到 project", d3.hits.length === 0 && d3.dropped.some((x) => x.reason === "too-short" && x.content === "OK"), JSON.stringify(d3));
+
 console.log("== scope ==");
 const s = resolveProjectScope(process.cwd());
 ok("kind=project", s.kind === "project");
@@ -220,6 +379,17 @@ ok("cwd scope deterministic", cwdOnly.key === cwdOnly2.key);
 // (This repo does have an origin after `git push`.)
 console.log("     cwd.key   =", cwdOnly.key);
 
+console.log("== scope (pickScopeRoot, D71) ==");
+// OpenCode v1 reports the filesystem root as `worktree` for non-git folders;
+// seeding a scope on it merges every non-git folder on the drive into one
+// shared `project__workspace__…` bucket. A real worktree still wins.
+const fsRoot = path.parse(process.cwd()).root;
+ok("real worktree wins", pickScopeRoot(process.cwd(), "/elsewhere/opened") === process.cwd());
+ok("fs-root worktree yields to directory", pickScopeRoot(fsRoot, process.cwd()) === process.cwd());
+ok("missing worktree uses directory", pickScopeRoot(null, process.cwd()) === process.cwd());
+ok("nothing but fs root: last resort", pickScopeRoot(fsRoot, null) === fsRoot);
+ok("no candidates falls back to cwd", pickScopeRoot(null, null) === process.cwd());
+
 console.log("== cjk ==");
 ok("detects han", hasCjk("中文记忆"));
 ok("detects mixed", hasCjk("open中文"));
@@ -399,6 +569,38 @@ ok("failed backup leaves legacy dir for retry", fs.existsSync(legacyRoot2));
 delete process.env.MY_O_MEMORY_HOME;
 fs.rmSync(tmpHome, { recursive: true, force: true });
 
+console.log("== env var names (D62) ==");
+{
+  const saved = {
+    n: process.env.OPEN_MEMEX_HOME,
+    l: process.env.MY_O_MEMORY_HOME,
+    nc: process.env.OPEN_MEMEX_CONFIG,
+    lc: process.env.MY_O_MEMORY_CONFIG,
+  };
+  const restore = () => {
+    const set = (k: string, v: string | undefined) => (v === undefined ? delete process.env[k] : (process.env[k] = v));
+    set("OPEN_MEMEX_HOME", saved.n);
+    set("MY_O_MEMORY_HOME", saved.l);
+    set("OPEN_MEMEX_CONFIG", saved.nc);
+    set("MY_O_MEMORY_CONFIG", saved.lc);
+  };
+  try {
+    delete process.env.OPEN_MEMEX_HOME;
+    delete process.env.MY_O_MEMORY_HOME;
+    ok("no override -> homeOverride null", homeOverride() === null);
+    process.env.MY_O_MEMORY_HOME = "/tmp/legacy-home";
+    ok("legacy fallback honored", dataRootPath().endsWith("legacy-home") && homeOverride()?.via === "MY_O_MEMORY_HOME");
+    process.env.OPEN_MEMEX_HOME = "/tmp/new-home";
+    ok("new name wins over legacy", dataRootPath().endsWith("new-home") && homeOverride()?.via === "OPEN_MEMEX_HOME");
+    process.env.MY_O_MEMORY_CONFIG = "/tmp/legacy.jsonc";
+    ok("config legacy fallback", configFilePath().endsWith("legacy.jsonc"));
+    process.env.OPEN_MEMEX_CONFIG = "/tmp/new.jsonc";
+    ok("config new name wins", configFilePath().endsWith("new.jsonc"));
+  } finally {
+    restore();
+  }
+}
+
 console.log("== lifecycle pure: contentHash / similarity ==");
 ok("hash deterministic + whitespace-insensitive", contentHash("hello   world\n") === contentHash("hello world"));
 ok("hash differs on content", contentHash("hello world") !== contentHash("hello mars"));
@@ -561,5 +763,27 @@ ok("opencode per-project keeps skill fallback", shouldInstallSkill("opencode", f
 ok("vscode keeps skill", shouldInstallSkill("vscode", true) === true);
 ok("cursor keeps skill", shouldInstallSkill("cursor", false) === true);
 
+// D68: display helpers — age tokens, structured lines, truncation notes.
+{
+  const { ageToken, formatInventoryLine, truncationNote } = await import("../src/retrieve/display.ts");
+  const now = Date.UTC(2026, 9, 3, 12, 0, 0);
+  ok("ageToken now", ageToken(now - 30_000, now) === "now");
+  ok("ageToken days", ageToken(now - 3 * 86_400_000, now) === "3d");
+  ok("ageToken old falls back to a date", /^\d{4}-\d{2}-\d{2}$/.test(ageToken(now - 90 * 86_400_000, now)));
+  const line = formatInventoryLine(2, {
+    id: "01K6AB", type: "fact", snippet: "likes  concise diffs", source: "user",
+    created_at: now - 3 * 86_400_000, updated_at: now - 3 * 86_400_000,
+    status: "active", review_state: "draft", scope_key: "personal",
+  }, "personal", now);
+  ok("inventory line is structured", line === "3. [fact] id=01K6AB created=3d source=user — likes concise diffs", line);
+  const proj = formatInventoryLine(0, {
+    id: "01K6CD", type: "decision", snippet: "ship on fridays", source: "keyword",
+    created_at: now - 2 * 86_400_000, updated_at: now - 3_600_000,
+    status: "active", review_state: "draft", scope_key: "project__x",
+  }, "personal", now);
+  ok("inventory line shows project state + late update", proj.includes("[draft]") && proj.includes("updated=1h"), proj);
+  ok("truncation note speaks only when cut", truncationNote(20, 54)?.includes("34 more") === true && truncationNote(20, 20) === null);
+}
+
 console.log(fails === 0 ? "\nALL PASS" : `\n${fails} FAILURES`);
 process.exit(fails === 0 ? 0 : 1);