@remnic/core 9.10.0 → 9.12.0

package/src/activity/digest.ts

@@ -0,0 +1,429 @@
+/**
+ * Deterministic screen-activity day-digest renderer (issue #1899).
+ *
+ * Renders a day's snapshots into markdown with YAML frontmatter, placed at
+ * `<memoryDir>/activity/<date>.md` — outside the memory scan roots but inside
+ * the QMD collection root (searchable, never auto-recalled). No LLM: the body
+ * is a pure, byte-identical function of its inputs so an unchanged day skips
+ * rewrite by contentHash. Day bucketing is DST-aware and half-open
+ * [start, end) (AGENTS.md §23); sort keys are total with stable tiebreakers
+ * (§12).
+ */
+
+import { createHash } from "node:crypto";
+import path from "node:path";
+
+import type { ActivityDayDigest, ActivityDayMeta, ActivitySnapshot } from "./types.js";
+
+export const ACTIVITY_DIGEST_FORMAT_VERSION = 1;
+export const ACTIVITY_DIR_NAME = "activity";
+
+/** Attribute at most this much dwell to a single snapshot (idle gaps capped). */
+const MAX_DWELL_MS = 15 * 60_000;
+/** Notable-excerpt caps. */
+const NOTABLE_MAX_WINDOWS = 10;
+const NOTABLE_EXCERPT_CHARS = 280;
+
+const DATE_PATTERN = /^\d{4}-\d{2}-\d{2}$/;
+
+export function isValidActivityDate(date: string): boolean {
+  if (typeof date !== "string" || !DATE_PATTERN.test(date)) return false;
+  // Reject impossible calendar days (e.g. 2026-02-30, 2026-13-01): the UTC
+  // round-trip must reproduce the same Y-M-D, else Date normalized an overflow.
+  const parsed = new Date(`${date}T00:00:00Z`);
+  return Number.isFinite(parsed.getTime()) && parsed.toISOString().slice(0, 10) === date;
+}
+
+export function activityDigestPath(memoryDir: string, date: string): string {
+  if (!isValidActivityDate(date)) {
+    // Never interpolate an unvalidated date into a filesystem path (a `../`
+    // would escape <memoryDir>/activity/). Reject loudly.
+    throw new RangeError(`Invalid activity date "${date}"; expected YYYY-MM-DD.`);
+  }
+  return path.join(memoryDir, ACTIVITY_DIR_NAME, `${date}.md`);
+}
+
+// ── DST-aware local-day window ──────────────────────────────────────────────
+
+function timezoneOffsetIso(instant: Date, timezone: string): string {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone: timezone,
+    timeZoneName: "longOffset",
+  }).formatToParts(instant);
+  const name = parts.find((part) => part.type === "timeZoneName")?.value ?? "GMT";
+  const match = name.match(/GMT([+-]\d{2}:\d{2})?/);
+  return match?.[1] ?? "+00:00";
+}
+
+function assertValidTimezone(timezone: string): void {
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: timezone });
+  } catch {
+    throw new RangeError(`Invalid IANA timezone "${timezone}" for the activity digest.`);
+  }
+}
+
+function zonedDayStartIso(date: string, timezone: string): string {
+  // The first UTC instant whose local wall-clock is this date at 00:00. Probe
+  // several instants across the day to collect every offset in play; keep an
+  // offset only if constructing local midnight with it lands back on that same
+  // offset (so it is genuinely local midnight, not a wall-clock that never
+  // occurred), then take the EARLIEST such instant — the FIRST 00:00 across a
+  // DST fall-back that repeats local midnight.
+  // Probe the previous UTC day too: for zones east of UTC the requested date's
+  // UTC instants all fall after local midnight, so the pre-transition offset
+  // valid at the real local 00:00 is only observable on the prior UTC day.
+  const prevDate = shiftIsoDate(date, -1);
+  const probeOffsets = new Set(
+    [
+      `${prevDate}T12:00:00Z`,
+      `${prevDate}T23:00:00Z`,
+      `${date}T00:00:00Z`,
+      `${date}T12:00:00Z`,
+      `${date}T23:00:00Z`,
+    ].map((iso) => timezoneOffsetIso(new Date(iso), timezone)),
+  );
+  let best: number | null = null;
+  for (const offset of probeOffsets) {
+    const candidate = Date.parse(`${date}T00:00:00${offset}`);
+    if (!Number.isFinite(candidate)) continue;
+    // Reject an offset whose local midnight does not actually occur (the wall
+    // clock skipped by a spring-forward): the offset in effect at the candidate
+    // instant must be the same offset we used to build it.
+    if (timezoneOffsetIso(new Date(candidate), timezone) !== offset) continue;
+    if (best === null || candidate < best) best = candidate;
+  }
+  if (best === null) {
+    // Local midnight was skipped by a spring-forward at 00:00. Advance to the
+    // first local wall-clock minute on this date that actually exists (never
+    // backdating to a 00:00 that never occurred), scanning forward up to 3h.
+    for (let minute = 1; minute <= 180 && best === null; minute++) {
+      const hh = String(Math.floor(minute / 60)).padStart(2, "0");
+      const mm = String(minute % 60).padStart(2, "0");
+      for (const offset of probeOffsets) {
+        const candidate = Date.parse(`${date}T${hh}:${mm}:00${offset}`);
+        if (!Number.isFinite(candidate)) continue;
+        if (timezoneOffsetIso(new Date(candidate), timezone) !== offset) continue;
+        if (best === null || candidate < best) best = candidate;
+      }
+    }
+  }
+  if (best === null) {
+    // Degenerate safety net: use the noon-derived offset for a deterministic start.
+    const noon = timezoneOffsetIso(new Date(`${date}T12:00:00Z`), timezone);
+    best = Date.parse(`${date}T00:00:00${noon}`);
+  }
+  if (best === null || !Number.isFinite(best)) {
+    throw new RangeError(`activity: could not resolve a local day start for "${date}" in "${timezone}".`);
+  }
+  return new Date(best).toISOString();
+}
+
+function shiftIsoDate(date: string, days: number): string {
+  const parsed = new Date(`${date}T00:00:00Z`);
+  parsed.setUTCDate(parsed.getUTCDate() + days);
+  return parsed.toISOString().slice(0, 10);
+}
+
+function nextIsoDate(date: string): string {
+  return shiftIsoDate(date, 1);
+}
+
+/** Half-open [start, end) UTC ISO bounds of a local day. */
+export function activityDayWindow(date: string, timezone: string): { startUtc: string; endUtc: string } {
+  if (!isValidActivityDate(date)) {
+    throw new RangeError(`Invalid activity date "${date}"; expected a real YYYY-MM-DD day.`);
+  }
+  assertValidTimezone(timezone);
+  return {
+    startUtc: new Date(zonedDayStartIso(date, timezone)).toISOString(),
+    endUtc: new Date(zonedDayStartIso(nextIsoDate(date), timezone)).toISOString(),
+  };
+}
+
+// ── Rendering ───────────────────────────────────────────────────────────────
+
+function sortedByTime(snapshots: ActivitySnapshot[]): ActivitySnapshot[] {
+  return [...snapshots].sort((a, b) => {
+    // Compare by parsed instant, not raw string, so mixed valid ISO forms
+    // (Z vs offset, varying precision) still order chronologically.
+    const at = Date.parse(a.capturedAtUtc);
+    const bt = Date.parse(b.capturedAtUtc);
+    if (at !== bt && Number.isFinite(at) && Number.isFinite(bt)) return at < bt ? -1 : 1;
+    const aid = a.id ?? 0;
+    const bid = b.id ?? 0;
+    if (aid < bid) return -1;
+    if (aid > bid) return 1;
+    // Unsaved snapshots (pre-store) both default to id 0; fall back to the
+    // content hash (their dedup identity), then app/window, for a total order.
+    if (a.contentHash !== b.contentHash) return a.contentHash < b.contentHash ? -1 : 1;
+    if (a.app !== b.app) return a.app < b.app ? -1 : 1;
+    if (a.windowTitle !== b.windowTitle) return a.windowTitle < b.windowTitle ? -1 : 1;
+    return 0;
+  });
+}
+
+/**
+ * Per-snapshot dwell (gap to that machine's next snapshot, capped), scoped per
+ * capture machine so an interleaved snapshot from another machine can't steal
+ * or truncate a snapshot's dwell (multi-machine days).
+ */
+function computeDwell(snapshots: ActivitySnapshot[]): Map<ActivitySnapshot, number> {
+  const byMachine = new Map<string, ActivitySnapshot[]>();
+  for (const snapshot of snapshots) {
+    const list = byMachine.get(snapshot.machine);
+    if (list === undefined) byMachine.set(snapshot.machine, [snapshot]);
+    else list.push(snapshot);
+  }
+  const dwell = new Map<ActivitySnapshot, number>();
+  for (const list of byMachine.values()) {
+    const ordered = sortedByTime(list);
+    for (let index = 0; index < ordered.length; index++) {
+      const current = ordered[index];
+      if (current === undefined) continue;
+      const next = ordered[index + 1];
+      let value = 0;
+      if (next !== undefined) {
+        const delta = Date.parse(next.capturedAtUtc) - Date.parse(current.capturedAtUtc);
+        if (Number.isFinite(delta) && delta > 0) value = Math.min(delta, MAX_DWELL_MS);
+      }
+      dwell.set(current, value);
+    }
+  }
+  return dwell;
+}
+
+function formatDurationMinutes(ms: number): string {
+  return `${Math.round(ms / 60_000)}m`;
+}
+
+function clockHhMm(iso: string, timezone: string): string {
+  const ms = Date.parse(iso);
+  if (!Number.isFinite(ms)) return "??:??";
+  const parts = new Intl.DateTimeFormat("en-GB", {
+    timeZone: timezone,
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false,
+  }).formatToParts(new Date(ms));
+  const hour = parts.find((p) => p.type === "hour")?.value ?? "00";
+  const minute = parts.find((p) => p.type === "minute")?.value ?? "00";
+  return `${hour}:${minute}`;
+}
+
+function collapseWhitespace(text: string): string {
+  return text.replace(/\s+/g, " ").trim();
+}
+
+function perAppSection(ordered: ActivitySnapshot[], dwell: Map<ActivitySnapshot, number>): string {
+  const totals = new Map<string, number>();
+  for (const snapshot of ordered) {
+    totals.set(snapshot.app, (totals.get(snapshot.app) ?? 0) + (dwell.get(snapshot) ?? 0));
+  }
+  const rows = [...totals.entries()].sort((a, b) => {
+    if (b[1] !== a[1]) return b[1] - a[1];
+    if (a[0] < b[0]) return -1;
+    if (a[0] > b[0]) return 1;
+    return 0;
+  });
+  const lines = ["## Per-app time", ""];
+  if (rows.length === 0) {
+    lines.push("_No activity recorded._");
+  } else {
+    for (const [app, ms] of rows) {
+      lines.push(`- ${app}: ${formatDurationMinutes(ms)}`);
+    }
+  }
+  return lines.join("\n");
+}
+
+interface TimelineSpan {
+  startIso: string;
+  machine: string;
+  app: string;
+  windowTitle: string;
+  browserUrl?: string;
+}
+
+function timelineSpans(ordered: ActivitySnapshot[]): TimelineSpan[] {
+  const spans: TimelineSpan[] = [];
+  for (const snapshot of ordered) {
+    const last = spans[spans.length - 1];
+    if (
+      last !== undefined &&
+      last.machine === snapshot.machine &&
+      last.app === snapshot.app &&
+      last.windowTitle === snapshot.windowTitle &&
+      last.browserUrl === snapshot.browserUrl
+    ) {
+      continue;
+    }
+    spans.push({
+      startIso: snapshot.capturedAtUtc,
+      machine: snapshot.machine,
+      app: snapshot.app,
+      windowTitle: snapshot.windowTitle,
+      ...(snapshot.browserUrl !== undefined ? { browserUrl: snapshot.browserUrl } : {}),
+    });
+  }
+  return spans;
+}
+
+function timelineSection(ordered: ActivitySnapshot[], timezone: string): string {
+  const lines = ["## Timeline", ""];
+  const spans = timelineSpans(ordered);
+  if (spans.length === 0) {
+    lines.push("_No activity recorded._");
+    return lines.join("\n");
+  }
+  for (const span of spans) {
+    const clock = clockHhMm(span.startIso, timezone);
+    const window = collapseWhitespace(span.windowTitle);
+    const url = span.browserUrl !== undefined ? ` (${collapseWhitespace(span.browserUrl)})` : "";
+    lines.push(`- [${clock}] ${span.app}${window.length > 0 ? ` — ${window}` : ""}${url}`);
+  }
+  return lines.join("\n");
+}
+
+function notableSection(ordered: ActivitySnapshot[], dwell: Map<ActivitySnapshot, number>): string {
+  const withDwell = ordered.map((snapshot) => ({ snapshot, dwell: dwell.get(snapshot) ?? 0 }));
+  const ranked = withDwell
+    .filter((entry) => collapseWhitespace(entry.snapshot.text).length > 0)
+    .sort((a, b) => {
+      if (b.dwell !== a.dwell) return b.dwell - a.dwell;
+      const at = Date.parse(a.snapshot.capturedAtUtc);
+      const bt = Date.parse(b.snapshot.capturedAtUtc);
+      if (at !== bt && Number.isFinite(at) && Number.isFinite(bt)) return at < bt ? -1 : 1;
+      const idDelta = (a.snapshot.id ?? 0) - (b.snapshot.id ?? 0);
+      if (idDelta !== 0) return idDelta;
+      if (a.snapshot.contentHash !== b.snapshot.contentHash) {
+        return a.snapshot.contentHash < b.snapshot.contentHash ? -1 : 1;
+      }
+      return 0;
+    })
+    .slice(0, NOTABLE_MAX_WINDOWS);
+  const lines = ["## Notable", ""];
+  if (ranked.length === 0) {
+    lines.push("_No notable text captured._");
+    return lines.join("\n");
+  }
+  for (const { snapshot } of ranked) {
+    const excerpt = collapseWhitespace(snapshot.text).slice(0, NOTABLE_EXCERPT_CHARS);
+    lines.push(`- **${snapshot.app}** — ${excerpt}`);
+  }
+  return lines.join("\n");
+}
+
+export function composeActivityDigestBody(
+  date: string,
+  timezone: string,
+  snapshots: ActivitySnapshot[],
+): string {
+  assertValidTimezone(timezone);
+  const ordered = sortedByTime(snapshots);
+  const dwell = computeDwell(ordered);
+  return [
+    `# Activity — ${date}`,
+    "",
+    perAppSection(ordered, dwell),
+    "",
+    timelineSection(ordered, timezone),
+    "",
+    notableSection(ordered, dwell),
+    "",
+  ].join("\n");
+}
+
+export function hashActivityBody(body: string): string {
+  return createHash("sha256").update(body, "utf8").digest("hex");
+}
+
+export function composeActivityDigestMeta(
+  date: string,
+  machines: string[],
+  snapshots: ActivitySnapshot[],
+  body: string,
+): ActivityDayMeta {
+  const uniqueMachines = [...new Set(machines)].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0));
+  return {
+    kind: "activity-digest",
+    date,
+    machines: uniqueMachines,
+    snapshotCount: snapshots.length,
+    contentHash: hashActivityBody(body),
+    formatVersion: ACTIVITY_DIGEST_FORMAT_VERSION,
+  };
+}
+
+export function serializeActivityDigest(meta: ActivityDayMeta, body: string): string {
+  const frontmatter = [
+    "---",
+    `kind: ${meta.kind}`,
+    `date: ${meta.date}`,
+    `machines: ${JSON.stringify(meta.machines)}`,
+    `snapshotCount: ${meta.snapshotCount}`,
+    `contentHash: ${meta.contentHash}`,
+    `formatVersion: ${meta.formatVersion}`,
+    "---",
+    "",
+  ].join("\n");
+  return `${frontmatter}${body}`;
+}
+
+export function parseActivityDigest(raw: string): ActivityDayDigest | null {
+  if (typeof raw !== "string" || !raw.startsWith("---\n")) return null;
+  const end = raw.indexOf("\n---\n", 4);
+  if (end === -1) return null;
+  const frontmatter = raw.slice(4, end);
+  const body = raw.slice(end + 5).replace(/^\n/, "");
+  const fields = new Map<string, string>();
+  for (const line of frontmatter.split("\n")) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    fields.set(line.slice(0, idx).trim(), line.slice(idx + 1).trim());
+  }
+  const date = fields.get("date");
+  const contentHash = fields.get("contentHash");
+  if (date === undefined || !isValidActivityDate(date) || contentHash === undefined) return null;
+  if (fields.get("kind") !== "activity-digest") return null;
+  const machines = parseMachinesList(fields.get("machines") ?? "[]");
+  const snapshotCount = parseNonNegativeInt(fields.get("snapshotCount"));
+  const formatVersion = parseNonNegativeInt(fields.get("formatVersion"));
+  if (snapshotCount === null || formatVersion === null) return null;
+  return {
+    meta: {
+      kind: "activity-digest",
+      date,
+      machines,
+      snapshotCount,
+      contentHash,
+      formatVersion,
+    },
+    body,
+  };
+}
+
+function parseNonNegativeInt(value: string | undefined): number | null {
+  if (value === undefined) return null;
+  const trimmed = value.trim();
+  if (!/^\d+$/.test(trimmed)) return null;
+  const parsed = Number(trimmed);
+  return Number.isSafeInteger(parsed) ? parsed : null;
+}
+
+function parseMachinesList(raw: string): string[] {
+  try {
+    const parsed: unknown = JSON.parse(raw);
+    if (Array.isArray(parsed)) {
+      return parsed.filter((entry): entry is string => typeof entry === "string");
+    }
+  } catch {
+    // Legacy unquoted inline form (`[a, b]`) — fall through to the split parse.
+  }
+  return raw
+    .replace(/^\[/, "")
+    .replace(/\]$/, "")
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter((entry) => entry.length > 0);
+}

package/src/activity/index.ts

@@ -0,0 +1,9 @@
+/**
+ * Public entry for the on-screen activity subsystem (issue #1900): the durable
+ * SQLite snapshot store plus the deterministic day-digest renderer. Re-exported
+ * from the package root (`src/index.ts`) so consumers import it from
+ * `@remnic/core`, matching the wearables subsystem's surfacing.
+ */
+export * from "./types.js";
+export * from "./store.js";
+export * from "./digest.js";

package/src/activity/store.test.ts

@@ -0,0 +1,226 @@
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { test } from "node:test";
+
+import { activityDayWindow } from "./digest.js";
+import { ActivityStore } from "./store.js";
+import type { ActivitySnapshot } from "./types.js";
+
+function snapshot(overrides: Partial<ActivitySnapshot> = {}): ActivitySnapshot {
+  return {
+    machine: "macstudio",
+    capturedAtUtc: "2026-03-10T14:00:00.000Z",
+    app: "Chrome",
+    windowTitle: "Roadmap",
+    text: "quarterly roadmap review",
+    textSource: "ax",
+    contentHash: "hash-a",
+    ...overrides,
+  };
+}
+
+async function withStore(fn: (store: ActivityStore) => void | Promise<void>): Promise<void> {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "activity-store-"));
+  const store = ActivityStore.open(dir);
+  try {
+    await fn(store);
+  } finally {
+    store.close();
+    await rm(dir, { recursive: true, force: true });
+  }
+}
+
+test("insertSnapshot dedups on (machine, content_hash)", async () => {
+  await withStore((store) => {
+    const first = store.insertSnapshot(snapshot());
+    const second = store.insertSnapshot(snapshot({ text: "different text, same hash" }));
+    assert.equal(first.inserted, true);
+    assert.equal(second.inserted, false);
+    assert.equal(second.id, first.id);
+    const rows = store.listSnapshotsForDay("macstudio", "2026-03-10T00:00:00.000Z", "2026-03-11T00:00:00.000Z");
+    assert.equal(rows.length, 1);
+  });
+});
+
+test("the same content_hash on a different machine is stored separately", async () => {
+  await withStore((store) => {
+    assert.equal(store.insertSnapshot(snapshot({ machine: "macstudio" })).inserted, true);
+    assert.equal(store.insertSnapshot(snapshot({ machine: "laptop" })).inserted, true);
+    const all = store.listSnapshotsForDay(null, "2026-03-10T00:00:00.000Z", "2026-03-11T00:00:00.000Z");
+    assert.equal(all.length, 2);
+  });
+});
+
+test("listSnapshotsForDay is half-open: a snapshot at the end bound is excluded", async () => {
+  await withStore((store) => {
+    store.insertSnapshot(snapshot({ contentHash: "h1", capturedAtUtc: "2026-03-10T00:00:00.000Z" }));
+    store.insertSnapshot(snapshot({ contentHash: "h2", capturedAtUtc: "2026-03-10T23:59:59.000Z" }));
+    store.insertSnapshot(snapshot({ contentHash: "h3", capturedAtUtc: "2026-03-11T00:00:00.000Z" }));
+    const rows = store.listSnapshotsForDay(null, "2026-03-10T00:00:00.000Z", "2026-03-11T00:00:00.000Z");
+    assert.deepEqual(rows.map((r) => r.contentHash), ["h1", "h2"]);
+  });
+});
+
+test("results are ordered by (captured_at_utc, id)", async () => {
+  await withStore((store) => {
+    store.insertSnapshot(snapshot({ contentHash: "b", capturedAtUtc: "2026-03-10T15:00:00.000Z" }));
+    store.insertSnapshot(snapshot({ contentHash: "a", capturedAtUtc: "2026-03-10T14:00:00.000Z" }));
+    const rows = store.listSnapshotsForDay(null, "2026-03-10T00:00:00.000Z", "2026-03-11T00:00:00.000Z");
+    assert.deepEqual(rows.map((r) => r.contentHash), ["a", "b"]);
+  });
+});
+
+test("cursors are per-machine and round-trip", async () => {
+  await withStore((store) => {
+    assert.equal(store.getCursor("macstudio"), null);
+    store.setCursor("macstudio", "cur-1");
+    store.setCursor("laptop", "cur-2");
+    assert.equal(store.getCursor("macstudio"), "cur-1");
+    assert.equal(store.getCursor("laptop"), "cur-2");
+    store.setCursor("macstudio", "cur-3");
+    assert.equal(store.getCursor("macstudio"), "cur-3");
+  });
+});
+
+test("searchSnapshots finds by text token and by app name", async () => {
+  await withStore((store) => {
+    store.insertSnapshot(snapshot({ contentHash: "h1", app: "Slack", text: "deploy the staging build" }));
+    store.insertSnapshot(snapshot({ contentHash: "h2", app: "Chrome", text: "unrelated content" }));
+    assert.equal(store.searchSnapshots("deploy", 10).length, 1);
+    assert.equal(store.searchSnapshots("Slack", 10)[0]?.app, "Slack");
+    assert.equal(store.searchSnapshots("nonexistentterm", 10).length, 0);
+  });
+});
+
+test("pruneOlderThan removes only rows before the cutoff, incl. their FTS rows", async () => {
+  await withStore((store) => {
+    store.insertSnapshot(snapshot({ contentHash: "old", capturedAtUtc: "2026-03-01T10:00:00.000Z", text: "ancient" }));
+    store.insertSnapshot(snapshot({ contentHash: "new", capturedAtUtc: "2026-03-10T10:00:00.000Z", text: "recent" }));
+    const removed = store.pruneOlderThan("2026-03-05T00:00:00.000Z");
+    assert.equal(removed, 1);
+    const all = store.listSnapshotsForDay(null, "2026-01-01T00:00:00.000Z", "2026-12-31T00:00:00.000Z");
+    assert.deepEqual(all.map((r) => r.contentHash), ["new"]);
+    // FTS row for the pruned snapshot is gone too.
+    assert.equal(store.searchSnapshots("ancient", 10).length, 0);
+    assert.equal(store.searchSnapshots("recent", 10).length, 1);
+  });
+});
+
+test("searchSnapshots never throws on FTS-special input (URLs, quotes, operators)", async () => {
+  await withStore((store) => {
+    store.insertSnapshot(
+      snapshot({ contentHash: "u", app: "Chrome", windowTitle: "PR", browserUrl: "https://github.com/x/pull/412", text: "review the change" }),
+    );
+    // URL with slashes/dots would be FTS5 syntax without sanitization.
+    assert.equal(store.searchSnapshots("github.com/x/pull/412", 10).length, 1);
+    // Bare boolean operators and quotes must not throw.
+    assert.doesNotThrow(() => store.searchSnapshots('AND OR "', 10));
+    assert.deepEqual(store.searchSnapshots("   ", 10), []);
+    assert.deepEqual(store.searchSnapshots('""', 10), []);
+  });
+});
+
+test("ActivityStore.open works on a fresh memoryDir (creates state/ itself)", async () => {
+  const dir = await mkdtemp(path.join(os.tmpdir(), "activity-fresh-"));
+  try {
+    // No pre-created state/ dir: the public factory must not throw.
+    const store = ActivityStore.open(dir);
+    const result = store.insertSnapshot(snapshot());
+    assert.equal(result.inserted, true);
+    store.close();
+  } finally {
+    await rm(dir, { recursive: true, force: true });
+  }
+});
+
+test("insertSnapshot writes the FTS row atomically (searchable right after insert)", async () => {
+  await withStore((store) => {
+    const result = store.insertSnapshot(snapshot({ text: "atomic search token zzq", contentHash: "atomic-1" }));
+    assert.equal(result.inserted, true);
+    // A committed base row without its FTS row would return zero hits here.
+    const hits = store.searchSnapshots("zzq", 10);
+    assert.equal(hits.length, 1);
+    assert.equal(hits[0]?.contentHash, "atomic-1");
+  });
+});
+
+test("dedup keeps the same content at a different time; exact re-ingest dedups", async () => {
+  await withStore((store) => {
+    const first = store.insertSnapshot(snapshot({ capturedAtUtc: "2026-03-10T14:00:00.000Z", contentHash: "same" }));
+    const later = store.insertSnapshot(snapshot({ capturedAtUtc: "2026-03-10T15:00:00.000Z", contentHash: "same" }));
+    const dup = store.insertSnapshot(snapshot({ capturedAtUtc: "2026-03-10T14:00:00.000Z", contentHash: "same" }));
+    assert.equal(first.inserted, true);
+    assert.equal(later.inserted, true); // same content, different time → kept
+    assert.equal(dup.inserted, false); // exact re-ingestion → deduped
+  });
+});
+
+test("captured timestamps are canonicalized so day-window filtering matches", async () => {
+  await withStore((store) => {
+    // Non-canonical inputs (explicit +00:00 offset, missing millis) must land in the day.
+    store.insertSnapshot(snapshot({ capturedAtUtc: "2026-03-10T14:00:00+00:00", contentHash: "c1" }));
+    store.insertSnapshot(snapshot({ capturedAtUtc: "2026-03-10T15:30:00Z", contentHash: "c2" }));
+    const { startUtc, endUtc } = activityDayWindow("2026-03-10", "UTC");
+    const rows = store.listSnapshotsForDay(null, startUtc, endUtc);
+    assert.equal(rows.length, 2);
+    assert.ok(rows.every((r) => r.capturedAtUtc.endsWith("Z") && r.capturedAtUtc.includes(".")));
+  });
+});
+
+test("insertSnapshot rejects an impossible capture timestamp", async () => {
+  await withStore((store) => {
+    assert.throws(
+      () => store.insertSnapshot(snapshot({ capturedAtUtc: "2026-02-30T10:00:00.000Z", contentHash: "bad" })),
+      RangeError,
+    );
+  });
+});
+
+test("insertSnapshot rejects an offset-form impossible timestamp", async () => {
+  await withStore((store) => {
+    assert.throws(
+      () => store.insertSnapshot(snapshot({ capturedAtUtc: "2026-02-30T14:00:00.000+00:00", contentHash: "bad2" })),
+      RangeError,
+    );
+  });
+});
+
+test("pruneOlderThan canonicalizes a non-canonical cutoff", async () => {
+  await withStore((store) => {
+    store.insertSnapshot(snapshot({ capturedAtUtc: "2026-03-10T09:00:00.000Z", contentHash: "old" }));
+    store.insertSnapshot(snapshot({ capturedAtUtc: "2026-03-10T11:00:00.000Z", contentHash: "new" }));
+    // A non-canonical cutoff (no millis) must still prune the 09:00 snapshot.
+    assert.equal(store.pruneOlderThan("2026-03-10T10:00:00Z"), 1);
+  });
+});
+
+test("pruneOlderThan rejects a malformed cutoff instead of deleting by a raw string compare", async () => {
+  await withStore((store) => {
+    store.insertSnapshot(snapshot({ capturedAtUtc: "2026-03-10T09:00:00.000Z", contentHash: "keep" }));
+    assert.throws(() => store.pruneOlderThan("not-a-date"), RangeError);
+    // The valid row survived the rejected prune.
+    const { startUtc, endUtc } = activityDayWindow("2026-03-10", "UTC");
+    assert.equal(store.listSnapshotsForDay(null, startUtc, endUtc).length, 1);
+  });
+});
+
+test("insertSnapshot rejects a snapshot missing a required field", async () => {
+  await withStore((store) => {
+    assert.throws(() => store.insertSnapshot(snapshot({ contentHash: "" })), RangeError);
+    assert.throws(() => store.insertSnapshot(snapshot({ machine: undefined as unknown as string })), RangeError);
+  });
+});
+
+test("listSnapshotsForDay rejects a malformed range bound", async () => {
+  await withStore((store) => {
+    assert.throws(() => store.listSnapshotsForDay(null, "not-a-date", "2026-03-11T00:00:00.000Z"), RangeError);
+  });
+});
+
+test("insertSnapshot rejects an unknown textSource", async () => {
+  await withStore((store) => {
+    assert.throws(() => store.insertSnapshot(snapshot({ textSource: "screen" as unknown as "ax" })), RangeError);
+  });
+});