@remnic/core 9.66.8 → 9.66.10

package/src/dedup/merge-decision.ts

@@ -0,0 +1,78 @@
+/**
+ * Pure create/update/skip decision for merge-on-write (issue #2330 slice).
+ *
+ * No I/O, no LLM. Invalid thresholds throw RangeError; bad candidates are
+ * ignored, never thrown on. `below_threshold` is reserved for a later slice.
+ */
+
+export type MergeDecision =
+  | { action: "create" }
+  | { action: "update"; targetId: string }
+  | { action: "skip"; reason: "duplicate" | "below_threshold" };
+
+export interface MergeCandidate {
+  id: string;
+  similarity: number; // 0..1
+  updatedAt: string; // ISO
+}
+
+export interface MergeDecisionOptions {
+  updateThreshold: number; // >= this similarity -> update
+  duplicateThreshold: number; // >= this similarity -> skip as duplicate
+}
+
+function assertThreshold(value: number, name: string): void {
+  if (!Number.isFinite(value) || value < 0 || value > 1) {
+    throw new RangeError(`invalid ${name}: ${value}`);
+  }
+}
+
+/** Total order: similarity desc, then updatedAt desc, then id asc. NaN times sort last. */
+function compareCandidates(a: MergeCandidate, b: MergeCandidate): number {
+  if (a.similarity !== b.similarity) return b.similarity - a.similarity;
+  // Date.parse never throws; unparseable timestamps yield NaN and sort last.
+  // NaN !== NaN, so the two sides must be classified as a pair: testing each
+  // independently returned 1 for BOTH orderings when both were unparseable,
+  // which breaks antisymmetry and made the winner depend on array order.
+  const aTime = Date.parse(a.updatedAt);
+  const bTime = Date.parse(b.updatedAt);
+  const aUnparseable = Number.isNaN(aTime);
+  const bUnparseable = Number.isNaN(bTime);
+  if (aUnparseable !== bUnparseable) return aUnparseable ? 1 : -1;
+  if (!aUnparseable && aTime !== bTime) return bTime - aTime;
+  return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+
+export function decideMergeOnWrite(
+  candidates: readonly MergeCandidate[],
+  options: MergeDecisionOptions,
+): MergeDecision {
+  assertThreshold(options.updateThreshold, "updateThreshold");
+  assertThreshold(options.duplicateThreshold, "duplicateThreshold");
+  if (options.duplicateThreshold < options.updateThreshold) {
+    throw new RangeError(
+      `duplicateThreshold ${options.duplicateThreshold} < updateThreshold ${options.updateThreshold}`,
+    );
+  }
+
+  const valid = candidates.filter(
+    (c) =>
+      typeof c.id === "string" &&
+      c.id.trim() !== "" &&
+      typeof c.similarity === "number" &&
+      Number.isFinite(c.similarity) &&
+      c.similarity >= 0 &&
+      c.similarity <= 1,
+  );
+  if (valid.length === 0) return { action: "create" };
+
+  const best = valid.reduce((acc, c) => (compareCandidates(c, acc) < 0 ? c : acc));
+
+  if (best.similarity >= options.duplicateThreshold) {
+    return { action: "skip", reason: "duplicate" };
+  }
+  if (best.similarity >= options.updateThreshold) {
+    return { action: "update", targetId: best.id };
+  }
+  return { action: "create" };
+}

package/src/extraction-span-tokens.test.ts

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import { test } from "node:test";
+import {
+  estimateGeneratedTokens,
+  estimateOffsetTokens,
+  spanModeSavesTokens,
+} from "./extraction-span-tokens.js";
+
+test("estimateGeneratedTokens: 0 chars -> 0 tokens", () => {
+  assert.equal(estimateGeneratedTokens(0), 0);
+});
+
+test("estimateGeneratedTokens: 1..4 chars -> 1 token", () => {
+  for (const chars of [1, 2, 3, 4]) {
+    assert.equal(estimateGeneratedTokens(chars), 1);
+  }
+});
+
+test("estimateGeneratedTokens: 5 chars -> 2 tokens", () => {
+  assert.equal(estimateGeneratedTokens(5), 2);
+});
+
+test("estimateGeneratedTokens: invalid charCount throws", () => {
+  assert.throws(() => estimateGeneratedTokens(-1), /charCount/);
+  assert.throws(() => estimateGeneratedTokens(Number.NaN), /charCount/);
+  assert.throws(() => estimateGeneratedTokens(3.7), /charCount/);
+  assert.throws(() => estimateGeneratedTokens(-1), RangeError);
+  assert.throws(() => estimateGeneratedTokens(Number.NaN), RangeError);
+});
+
+test("estimateOffsetTokens: (0, 12) cost is a positive integer", () => {
+  const cost = estimateOffsetTokens(0, 12);
+  assert.equal(Number.isInteger(cost), true);
+  assert.ok(cost > 0);
+});
+
+test("estimateOffsetTokens: offset 0 costs one character (one token)", () => {
+  assert.equal(estimateOffsetTokens(0, 0), 2);
+});
+
+test("estimateOffsetTokens: reversed span throws", () => {
+  assert.throws(() => estimateOffsetTokens(13, 12), RangeError);
+  assert.throws(() => estimateOffsetTokens(13, 12), /reversed/);
+});
+
+test("estimateOffsetTokens: non-finite or non-integer offsets throw", () => {
+  assert.throws(() => estimateOffsetTokens(Number.NaN, 12), RangeError);
+  assert.throws(() => estimateOffsetTokens(0, Number.POSITIVE_INFINITY), RangeError);
+  assert.throws(() => estimateOffsetTokens(0.5, 12), RangeError);
+});
+
+test("spanModeSavesTokens: long generated value beats small offsets", () => {
+  assert.equal(
+    spanModeSavesTokens({ generatedCharCount: 1000, start: 0, end: 12 }),
+    true,
+  );
+});
+
+test("spanModeSavesTokens: equal costs return false", () => {
+  // (0, 12) costs 2 tokens; 5..8 generated chars also cost 2 tokens.
+  assert.equal(
+    spanModeSavesTokens({ generatedCharCount: 8, start: 0, end: 12 }),
+    false,
+  );
+  assert.equal(
+    spanModeSavesTokens({ generatedCharCount: 5, start: 0, end: 0 }),
+    false,
+  );
+});

package/src/extraction-span-tokens.ts

@@ -0,0 +1,44 @@
+/**
+ * Isolated span token-cost estimator (issue #2333, Phase A).
+ *
+ * Pure. Estimates the output-token cost of emitting span offsets versus
+ * generating the memory value, so the Phase A bench can compare both sides
+ * without touching the extraction engine.
+ */
+
+const CHARS_PER_TOKEN = 4;
+
+export function estimateGeneratedTokens(charCount: number): number {
+  if (!Number.isInteger(charCount) || charCount < 0) {
+    throw new RangeError(`charCount must be a non-negative integer, got ${charCount}`);
+  }
+  return Math.ceil(charCount / CHARS_PER_TOKEN);
+}
+
+export function estimateOffsetTokens(start: number, end: number): number {
+  if (!Number.isInteger(start)) {
+    throw new RangeError(`start must be a finite integer, got ${start}`);
+  }
+  if (!Number.isInteger(end)) {
+    throw new RangeError(`end must be a finite integer, got ${end}`);
+  }
+  if (start > end) {
+    throw new RangeError(`reversed span: start ${start} > end ${end}`);
+  }
+  return offsetTokens(start) + offsetTokens(end);
+}
+
+export function spanModeSavesTokens(input: {
+  generatedCharCount: number;
+  start: number;
+  end: number;
+}): boolean {
+  return (
+    estimateOffsetTokens(input.start, input.end) <
+    estimateGeneratedTokens(input.generatedCharCount)
+  );
+}
+
+function offsetTokens(offset: number): number {
+  return Math.ceil(String(offset).length / CHARS_PER_TOKEN);
+}

package/src/lcm/engine.ts

@@ -12,6 +12,7 @@ import { LcmWorkQueue, type LcmObserveMessage } from "./queue.js";
 import type { PluginConfig } from "../types.js";
 import { estimateTokenCount } from "../token-estimate.js";
 import { log } from "../logger.js";
+import { nativeBindingRecoveryHint } from "../native-binding-hint.js";
 export interface LcmEngineConfig {
   enabled: boolean;
   leafBatchSize: number;
@@ -225,7 +226,9 @@ export class LcmEngine {
       })
       .catch((err) => {
         if (this.closed) return;
-        log.error(`LCM observe enqueue initialization error: ${err}`);
+        log.error(
+          `LCM observe enqueue initialization error: ${err}${nativeBindingRecoveryHint(err)}`,
+        );
       })
       .finally(() => {
         this.releasePendingObserveInit(normalizedSessionId);

package/src/native-binding-hint.test.ts

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { isNativeBindingError, nativeBindingRecoveryHint } from "./native-binding-hint.js";
+
+test("recognizes the bindings-resolution failure operators actually see", () => {
+  const error = new Error(
+    "Could not locate the bindings file. Tried:\n → .../better-sqlite3/build/Release/better_sqlite3.node",
+  );
+  assert.equal(isNativeBindingError(error), true);
+  const hint = nativeBindingRecoveryHint(error);
+  assert.match(hint, /npm rebuild better-sqlite3 --build-from-source/);
+  assert.match(hint, new RegExp(`ABI ${process.versions.modules}\\b`));
+  assert.match(hint, new RegExp(`Node ${process.versions.node.split(".")[0]}\\b`));
+});
+
+test("recognizes an ABI mismatch reported as NODE_MODULE_VERSION", () => {
+  const error = new Error(
+    "The module was compiled against a different Node.js version using NODE_MODULE_VERSION 127. " +
+      "This version of Node.js requires NODE_MODULE_VERSION 141.",
+  );
+  assert.equal(isNativeBindingError(error), true);
+  assert.match(nativeBindingRecoveryHint(error), /--build-from-source/);
+});
+
+test("an unrelated error yields no hint so its message reads unchanged", () => {
+  const error = new Error("SQLITE_BUSY: database is locked");
+  assert.equal(isNativeBindingError(error), false);
+  assert.equal(nativeBindingRecoveryHint(error), "");
+});
+
+test("non-Error inputs are handled without throwing", () => {
+  assert.equal(isNativeBindingError(undefined), false);
+  assert.equal(isNativeBindingError(null), false);
+  assert.equal(nativeBindingRecoveryHint({}), "");
+  assert.equal(isNativeBindingError("could not locate the bindings file"), true);
+  assert.match(nativeBindingRecoveryHint("invalid ELF header"), /--build-from-source/);
+});

package/src/native-binding-hint.ts

@@ -0,0 +1,51 @@
+/**
+ * Actionable recovery hint for a missing or ABI-mismatched better-sqlite3
+ * native binding (issue #2719).
+ *
+ * `better-sqlite3` publishes prebuilds for LTS Node only, so a newer runtime
+ * installs the package with no loadable binding and every SQLite-backed path
+ * fails with a bindings-resolution error. The raw error names neither the
+ * running ABI nor the command that fixes it, so operators saw only
+ * "Could not locate the bindings file" at first use.
+ *
+ * The repair itself lives in the `@remnic/core` postinstall script — an
+ * OpenClaw plugin package may not ship a child-process-spawning file, so the
+ * host-facing packages surface this hint instead of re-implementing a rebuild.
+ */
+
+/** Substrings that identify a native-binding load failure, lowercased. */
+const BINDING_ERROR_MARKERS = [
+  "could not locate the bindings file",
+  "was compiled against a different node.js version",
+  "node_module_version",
+  "invalid elf header",
+  "better_sqlite3.node",
+];
+
+function messageOf(error: unknown): string {
+  if (error instanceof Error) return error.message;
+  if (typeof error === "string") return error;
+  return "";
+}
+
+/** True when the error is a better-sqlite3 native-binding load failure. */
+export function isNativeBindingError(error: unknown): boolean {
+  const message = messageOf(error).toLowerCase();
+  if (message.length === 0) return false;
+  return BINDING_ERROR_MARKERS.some((marker) => message.includes(marker));
+}
+
+/**
+ * Suffix naming the running Node ABI and the exact rebuild command, or an
+ * empty string when the error is unrelated. Callers append it to their own
+ * message so an unrelated failure reads exactly as before.
+ */
+export function nativeBindingRecoveryHint(error: unknown): string {
+  if (!isNativeBindingError(error)) return "";
+  const major = process.versions.node.split(".")[0] ?? process.versions.node;
+  return (
+    ` — better-sqlite3 has no loadable native binding for Node ${major}` +
+    ` (ABI ${process.versions.modules}); rebuild it with` +
+    " `npm rebuild better-sqlite3 --build-from-source`"
+  );
+}

package/src/recall-deep-frontier.test.ts

@@ -0,0 +1,85 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { DEEP_RECALL_FRONTIER_CAP, rankDeepRecallFrontier } from "./recall-deep-frontier.js";
+
+test("empty input returns empty", () => {
+  assert.deepEqual(rankDeepRecallFrontier([]), []);
+});
+
+test("blank nodeIds and counts below 1 are dropped", () => {
+  const result = rankDeepRecallFrontier([
+    { nodeId: "", sharedAnchorCount: 3 },
+    { nodeId: "   ", sharedAnchorCount: 3 },
+    { nodeId: "a", sharedAnchorCount: 0 },
+    { nodeId: "b", sharedAnchorCount: -2 },
+    { nodeId: "c", sharedAnchorCount: 1 },
+  ]);
+  assert.deepEqual(result, [{ nodeId: "c", sharedAnchorCount: 1 }]);
+});
+
+test("NaN and infinite counts are dropped", () => {
+  const result = rankDeepRecallFrontier([
+    { nodeId: "a", sharedAnchorCount: Number.NaN },
+    { nodeId: "b", sharedAnchorCount: Number.POSITIVE_INFINITY },
+    { nodeId: "c", sharedAnchorCount: 2 },
+  ]);
+  assert.deepEqual(result, [{ nodeId: "c", sharedAnchorCount: 2 }]);
+});
+
+test("dedup by nodeId keeps the higher count, first on tie", () => {
+  const result = rankDeepRecallFrontier([
+    { nodeId: "a", sharedAnchorCount: 2 },
+    { nodeId: "a", sharedAnchorCount: 5 },
+    { nodeId: "b", sharedAnchorCount: 4 },
+    { nodeId: "b", sharedAnchorCount: 4 },
+  ]);
+  assert.deepEqual(result, [
+    { nodeId: "a", sharedAnchorCount: 5 },
+    { nodeId: "b", sharedAnchorCount: 4 },
+  ]);
+});
+
+test("sorts by count desc then nodeId asc", () => {
+  const result = rankDeepRecallFrontier([
+    { nodeId: "c", sharedAnchorCount: 3 },
+    { nodeId: "a", sharedAnchorCount: 3 },
+    { nodeId: "b", sharedAnchorCount: 9 },
+    { nodeId: "d", sharedAnchorCount: 1 },
+  ]);
+  assert.deepEqual(
+    result.map((candidate) => candidate.nodeId),
+    ["b", "a", "c", "d"],
+  );
+});
+
+test("caps at 20 keeping the top 20 of 21", () => {
+  const candidates = Array.from({ length: 21 }, (_, i) => ({
+    nodeId: `n${String(i).padStart(2, "0")}`,
+    sharedAnchorCount: i + 1,
+  }));
+  const result = rankDeepRecallFrontier(candidates);
+  assert.equal(result.length, DEEP_RECALL_FRONTIER_CAP);
+  assert.equal(result[0]?.nodeId, "n20");
+  assert.equal(result.at(-1)?.nodeId, "n01");
+  assert.ok(!result.some((candidate) => candidate.nodeId === "n00"));
+});
+
+test("does not mutate the input array or its objects", () => {
+  const input = [
+    { nodeId: " b ", sharedAnchorCount: 2 },
+    { nodeId: "a", sharedAnchorCount: 1 },
+  ];
+  const snapshot = structuredClone(input);
+  rankDeepRecallFrontier(input);
+  assert.deepEqual(input, snapshot);
+});
+
+test("two calls on the same input are deep-equal", () => {
+  const input = [
+    { nodeId: "a", sharedAnchorCount: 2 },
+    { nodeId: "b", sharedAnchorCount: 2 },
+    { nodeId: "a", sharedAnchorCount: 7 },
+  ];
+  assert.deepEqual(rankDeepRecallFrontier(input), rankDeepRecallFrontier(input));
+});

package/src/recall-deep-frontier.ts

@@ -0,0 +1,39 @@
+/**
+ * Deep-recall frontier ranker (issue #2332).
+ *
+ * Pure. After every working-set change the frontier is capped at
+ * DEEP_RECALL_FRONTIER_CAP items ordered by shared-anchor count
+ * descending, then nodeId ascending — a total comparator.
+ */
+
+export const DEEP_RECALL_FRONTIER_CAP = 20;
+
+export interface DeepRecallFrontierCandidate {
+  nodeId: string;
+  sharedAnchorCount: number;
+}
+
+export function rankDeepRecallFrontier(
+  candidates: readonly DeepRecallFrontierCandidate[],
+): DeepRecallFrontierCandidate[] {
+  const byNodeId = new Map<string, DeepRecallFrontierCandidate>();
+  for (const candidate of candidates) {
+    const nodeId = typeof candidate.nodeId === "string" ? candidate.nodeId.trim() : "";
+    if (nodeId === "") continue;
+    const count = candidate.sharedAnchorCount;
+    if (typeof count !== "number" || !Number.isFinite(count) || count < 1) continue;
+    const kept = byNodeId.get(nodeId);
+    if (kept === undefined || count > kept.sharedAnchorCount) {
+      byNodeId.set(nodeId, { nodeId, sharedAnchorCount: count });
+    }
+  }
+  return [...byNodeId.values()]
+    .sort((a, b) => {
+      if (a.sharedAnchorCount !== b.sharedAnchorCount) {
+        return b.sharedAnchorCount - a.sharedAnchorCount;
+      }
+      if (a.nodeId !== b.nodeId) return a.nodeId < b.nodeId ? -1 : 1;
+      return 0;
+    })
+    .slice(0, DEEP_RECALL_FRONTIER_CAP);
+}

package/src/standup/build.test.ts

@@ -4,30 +4,156 @@ import os from "node:os";
 import path from "node:path";
 import test from "node:test";
 
-import { buildStandup, parseStandupDate, previousDate } from "./build.js";
+import { buildStandup, parseStandupDate, previousActiveDate } from "./build.js";
 
-test("parseStandupDate rejects garbage and defaults to UTC today", () => {
+const FRONTMATTER = (date: string): string => `---\nid: digest-${date}\ncategory: fact\nstatus: active\n---\n`;
+
+test("parseStandupDate defaults only on absence, rejects garbage and empty", () => {
   assert.equal(parseStandupDate(undefined, new Date("2026-08-18T12:00:00Z")), "2026-08-18");
+  assert.equal(parseStandupDate(null, new Date("2026-08-18T12:00:00Z")), "2026-08-18");
   assert.throws(() => parseStandupDate("nope"), /YYYY-MM-DD/);
-  assert.equal(previousDate("2026-08-18"), "2026-08-17");
+  // An explicitly empty date is user input, not absence (§39: reject, never
+  // silently default).
+  assert.throws(() => parseStandupDate(""), /YYYY-MM-DD/);
+});
+
+test("previousActiveDate falls back to calendar-previous when no digests exist", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-standup-"));
+  try {
+    assert.equal(previousActiveDate(memoryDir, "2026-08-18"), "2026-08-17");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("previousActiveDate skips idle weekend days (Monday resolves to Friday)", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-standup-"));
+  try {
+    await mkdir(path.join(memoryDir, "activity"), { recursive: true });
+    // 2026-08-17 is a Monday; 2026-08-14 is the prior Friday (derived from
+    // `date -d`, not memory). Weekend has no digest files.
+    await writeFile(path.join(memoryDir, "activity", "2026-08-14.md"), "x\n", "utf8");
+    assert.equal(previousActiveDate(memoryDir, "2026-08-17"), "2026-08-14");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("previousActiveDate picks the most recent active day, not a fixed weekday", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-standup-"));
+  try {
+    await mkdir(path.join(memoryDir, "activity"), { recursive: true });
+    // Sunday activity counts: prior day is the latest day WITH data.
+    await writeFile(path.join(memoryDir, "activity", "2026-08-16.md"), "x\n", "utf8");
+    assert.equal(previousActiveDate(memoryDir, "2026-08-17"), "2026-08-16");
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
 });
 
-test("buildStandup is deterministic and marks missing days", async () => {
+function digestBody(spans: string[]): string {
+  return ["## Timeline", "", ...spans].join("\n");
+}
+
+test("buildStandup derives every section from the prior active day and stays deterministic", async () => {
   const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-standup-"));
   try {
     await mkdir(path.join(memoryDir, "activity"), { recursive: true });
+    // Friday 2026-08-14 has the activity; Monday 2026-08-17 is the standup day.
     await writeFile(
-      path.join(memoryDir, "activity", "2026-08-18.md"),
-      "---\ndate: 2026-08-18\n---\n# Today\n- shipped standup\n- blocker: waiting on review\n",
+      path.join(memoryDir, "activity", "2026-08-14.md"),
+      FRONTMATTER("2026-08-14") +
+        digestBody([
+          "- [09:00] Editor — refactor",
+          "- [09:30] Editor — refactor",
+          "- [10:15] Terminal — build",
+          "- [11:40] Editor — review",
+          "- [14:05] Browser — docs",
+          "- [15:20] Editor — blocker: waiting on review",
+        ]),
       "utf8",
     );
-    const a = buildStandup(memoryDir, "2026-08-18");
-    const b = buildStandup(memoryDir, "2026-08-18");
+    const a = buildStandup(memoryDir, "2026-08-17");
+    const b = buildStandup(memoryDir, "2026-08-17");
     assert.equal(a.markdown, b.markdown);
-    assert.equal(a.yesterday, "2026-08-17");
-    assert.match(a.markdown, /blocker: waiting on review/);
-    assert.match(a.activityGrid, /yesterday \| \./);
-    assert.match(a.activityGrid, /today \| x/);
+
+    assert.equal(a.yesterday, "2026-08-14");
+    // Highlights come from the PRIOR day (issue #1981), and frontmatter
+    // fields never leak into rendered sections.
+    assert.ok(a.highlights.length > 0);
+    for (const line of a.highlights) {
+      assert.doesNotMatch(line, /^id: |^category: |^status: |^---$/);
+    }
+    assert.match(a.markdown, /## Highlights\n- \[09:00\] Editor — refactor/);
+    // Blockers strip list markers (no doubled bullets) and come from P.
+    assert.ok(a.blockers.some((line) => line === "[15:20] Editor — blocker: waiting on review"));
+    assert.doesNotMatch(a.markdown, /- - /);
+    // Grid: exactly hours 9, 10, 11, 14, 15 non-empty; Monday empty.
+    assert.match(a.activityGrid, /^prior day 2026-08-14 — 24 hour buckets/);
+    assert.match(a.activityGrid, /^non-empty hours: 9, 10, 11, 14, 15$/m);
+    assert.match(a.markdown, /## Today \(2026-08-17\)\n_No activity digest._/);
+    // Zero commitments → explicit empty-priorities message, never invented.
+    assert.match(a.markdown, /## Today's priorities\n- \(no tracked commitments — add priorities manually\)/);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("buildStandup renders an empty grid row when the prior day has no digest", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-standup-"));
+  try {
+    const brief = buildStandup(memoryDir, "2026-08-18");
+    assert.match(brief.activityGrid, /^prior day 2026-08-17: no activity digest \(empty\)$/);
+  } finally {
+    await rm(memoryDir, { recursive: true, force: true });
+  }
+});
+
+test("buildStandup lists open commitments as priorities and overdue ones as blocker candidates", async () => {
+  const memoryDir = await mkdtemp(path.join(os.tmpdir(), "remnic-standup-"));
+  try {
+    await mkdir(path.join(memoryDir, "facts", "2026-08-10"), { recursive: true });
+    const commitment = (id: string, extra: string): string =>
+      `---\nid: ${id}\ncategory: commitment\nstatus: active\ncreated: 2026-08-10T00:00:00Z\nupdated: 2026-08-10T00:00:00Z\nsource: test\nconfidence: 0.8\nconfidenceTier: reported\ntags: []\n${extra}---\n${id} says: ship the thing\n`;
+    await writeFile(path.join(memoryDir, "facts", "2026-08-10", "open.md"), commitment("open-1", ""), "utf8");
+    await writeFile(
+      path.join(memoryDir, "facts", "2026-08-10", "due-soon.md"),
+      commitment("due-soon", "expiresAt: 2026-08-19T00:00:00Z\n"),
+      "utf8",
+    );
+    await writeFile(
+      path.join(memoryDir, "facts", "2026-08-10", "overdue.md"),
+      commitment("overdue-1", "expiresAt: 2026-08-15T00:00:00Z\n"),
+      "utf8",
+    );
+    await writeFile(
+      path.join(memoryDir, "facts", "2026-08-10", "fulfilled.md"),
+      commitment("done-1", "tags: [fulfilled]\n"),
+      "utf8",
+    );
+    await writeFile(
+      path.join(memoryDir, "facts", "2026-08-10", "review.md"),
+      commitment("pending-1", "status: pending_review\n"),
+      "utf8",
+    );
+    await writeFile(
+      path.join(memoryDir, "facts", "2026-08-10", "plain-fact.md"),
+      `---\nid: fact-1\ncategory: fact\nstatus: active\ncreated: 2026-08-10T00:00:00Z\nupdated: 2026-08-10T00:00:00Z\nsource: test\nconfidence: 0.8\nconfidenceTier: reported\ntags: []\n---\nnot a commitment\n`,
+      "utf8",
+    );
+
+    const brief = buildStandup(memoryDir, "2026-08-17");
+    // Overdue commitment is a blocker candidate, not a priority.
+    assert.ok(brief.blockers.some((line) => line.startsWith("commitment past due: overdue-1 says: ship the thing")));
+    // Fulfiled, pending-review, and non-commitment facts never appear.
+    const priorities = brief.priorities.join("\n");
+    assert.ok(priorities.includes("due-soon says: ship the thing (due 2026-08-19)"));
+    assert.ok(priorities.includes("open-1 says: ship the thing"));
+    assert.ok(!priorities.includes("done-1"));
+    assert.ok(!priorities.includes("pending-1"));
+    assert.ok(!priorities.includes("not a commitment"));
+    // Due-first ordering: expiresAt before bare created.
+    assert.ok(priorities.indexOf("due-soon") < priorities.indexOf("open-1"));
   } finally {
     await rm(memoryDir, { recursive: true, force: true });
   }